geo::TPCGeo Class Reference

geo::PlaneGeo::ComposePoint

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

Point

Definition: HitHandScan_module.cc:39

DefaultPoint_t geo::TPCGeo::ComposePoint ( DecomposedVector_t const & decomp ) const

inline

Definition at line 526 of file TPCGeo.h.

527 { return ComposePoint<DefaultPoint_t>(decomp); }

template<typename Point >

Point geo::TPCGeo::ComposePoint	(	double	distance,
		Projection_t const &	proj
	)		const

inline

Returns the 3D point from composition of projection and distance.

Template Parameters

Point type of point to be returned

Parameters

distance	distance of the target point from the reference plane
proj	projection of the target point on the reference plane

Returns: the 3D point from composition of projection and distance

See also: DecomposePoint()

The returned point is the reference point, translated by two 3D vectors:

a vector parallel to the plane normal, with norm the input distance
a vector lying on the plane, whose projection via PointProjection() gives the input projection

The choice of the projection reference point embodies the same convention used in PointProjection() and DecomposePoint().

Definition at line 550 of file TPCGeo.h.

551 { return ReferencePlane().ComposePoint<Point>(distance, proj); }

Point ComposePoint(WireDecomposedVector_t const &decomp) const

Returns the 3D point from composition of projection and distance.

Definition: PlaneGeo.h:1024

double distance(double x1, double y1, double z1, double x2, double y2, double z2)

Definition: truepionXsection_module.cc:217

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

Point

Definition: HitHandScan_module.cc:39

DefaultPoint_t geo::TPCGeo::ComposePoint	(	double	distance,
		Projection_t const &	proj
	)		const

inline

Definition at line 552 of file TPCGeo.h.

553 { return ComposePoint<DefaultPoint_t>(distance, proj); }

geo::TPCGeo::CoordinateContained

double distance(double x1, double y1, double z1, double x2, double y2, double z2)

Definition: truepionXsection_module.cc:217

double geo::TPCGeo::ComputeDriftDistance ( ) const

private

Computes the distance between the cathode and the last wire plane (last respect to the sorting order).

Definition at line 450 of file TPCGeo.cxx.

                                             {
 
     //
     // 1. find the center of the face of the TPC opposite to the anode
     // 2. compute the distance of it from the last wire plane
     //
 
     geo::PlaneGeo const& plane = fPlanes.back();
     return std::abs(plane.DistanceFromPlane(GetCathodeCenter()));
 
   } // TPCGeo::ComputeDriftDistance()

static bool geo::TPCGeo::CoordinateContained	(	double	c,
		double	min,
		double	max,
		double	wiggle = `1.`
	)

inlinestatic

Returns whether the specified coordinate is in a range.

Parameters

c	the coordinate
min	lower boundary of the range
max	upper boundary of the range
wiggle	expansion factor for the range

Returns: whether the specified coordinate is in a range

If the wiggle is larger than 1, the range is expanded by the wiggle factor. If the wiggle is less than 1, the range is shrinked.

Definition at line 692 of file TPCGeo.h.

       {
         return (c >= (min > 0? min / wiggle: min * wiggle))
           && (c <= (max < 0? max / wiggle: max * wiggle));
       } // CoordinateContained()

static bool geo::TPCGeo::CoordinateContained	(	double	c,
		double const *	range,
		double	wiggle = `1.`
	)

inlinestatic

Definition at line 699 of file TPCGeo.h.

700 { return CoordinateContained(c, range[0], range[1], wiggle); }

static bool CoordinateContained(double c, double min, double max, double wiggle=1.)

Returns whether the specified coordinate is in a range.

Definition: TPCGeo.h:692

ValidateOpDetSimulation.c

dictionary c

Definition: ValidateOpDetSimulation.py:57

DecomposedVector_t geo::TPCGeo::DecomposePoint ( geo::Point_t const & point ) const

inline

Decomposes a 3D point in two components.

Parameters

point the point to be decomposed

Returns: the two components of point, on the plane and orthogonal to it

The point is decomposed in:

a component orthogonal to the reference plane, expressed as a signed real number
a component lying on the reference plane, expressed as a 2D vector

The distance is from the reference plane (DistanceFromReferencePlane()). The projection on the plane is obtained following the same convention as PointProjection().

Definition at line 445 of file TPCGeo.h.

446 { return ReferencePlane().DecomposePointWidthDepth(point); }

geo::PlaneGeo::DecomposePointWidthDepth

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

WDDecomposedVector_t DecomposePointWidthDepth(geo::Point_t const &point) const

Decomposes a 3D point in two components.

Definition: PlaneGeo.h:1088

DecomposedVector_t geo::TPCGeo::DecomposePoint ( TVector3 const & point ) const

inline

Definition at line 447 of file TPCGeo.h.

448 { return DecomposePoint(geo::vect::toPoint(point)); }

geo::vect::toPoint

::geo::Point_t toPoint(Point const &p)

Convert the specified point into a geo::Point_t.

Definition: geo_vectors_utils.h:1280

geo::TPCGeo::DecomposePoint

DecomposedVector_t DecomposePoint(geo::Point_t const &point) const

Decomposes a 3D point in two components.

Definition: TPCGeo.h:445

short int geo::TPCGeo::DetectDriftDirection ( ) const

Returns the expected drift direction based on geometry.

The return value is coded as follow:

+1: positive x
+2: positive y
+3: positive z
-1: negative x
-2: negative y
-3: negative z
0: other (or algorithm failed)

The current implementation is based on the assumption that electrons in the middle of TPC will drift toward the wire planes, and it "never fails".

Definition at line 157 of file TPCGeo.cxx.

                                                {
 
     //
     // 1. determine the drift axis
     // 2. determine the drift direction on it
     //
     // We assume that all the planes cover most of the TPC face; therefore,
     // the centre of the plane and the one of the TPC should be very close
     // to each other, when projected on the same drift plane.
     // Here we find which is the largest coordinate difference.
 
     if (Nplanes() == 0) {
       // chances are that we get this because stuff is not initialised yet,
       // and then even the ID might be wrong
       throw cet::exception("TPCGeo")
         << "DetectDriftDirection(): no planes in TPC " << std::string(ID())
         << "\n";
     }
 
     auto const TPCcenter = GetCenter();
     auto const PlaneCenter = Plane(0).GetBoxCenter(); // any will do
 
     auto const driftVector = PlaneCenter - TPCcenter; // approximation!
 
     if ((std::abs(driftVector.X()) > std::abs(driftVector.Y()))
       && (std::abs(driftVector.X()) > std::abs(driftVector.Z())))
     {
       // x is the solution
       return (driftVector.X() > 0)? +1: -1;
     }
     else if (std::abs(driftVector.Y()) > std::abs(driftVector.Z()))
     {
       // y is the man
       return (driftVector.Y() > 0)? +2: -2;
     }
     else {
       // z is the winner
       return (driftVector.Z() > 0)? +3: -3;
     }
 
   } // TPCGeo::DetectDriftDirection()

double geo::TPCGeo::DistanceFromReferencePlane ( geo::Point_t const & point ) const

inline

Returns the distance of the specified point from reference plane.

Parameters

point a point in world coordinates [cm]

Returns: the signed distance from the plane

The distance is defined positive if the point lies in the inner side with respect to the reference plane.

It should match the drift distance from that plane.

Definition at line 404 of file TPCGeo.h.

405 { return ReferencePlane().DistanceFromPlane(point); }

geo::PlaneGeo::DistanceFromPlane

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

double DistanceFromPlane(geo::Point_t const &point) const

Returns the distance of the specified point from the wire plane.

Definition: PlaneGeo.h:621

double geo::TPCGeo::DistanceFromReferencePlane ( TVector3 const & point ) const

inline

Definition at line 406 of file TPCGeo.h.

407 { return DistanceFromReferencePlane(geo::vect::toPoint(point)); }

geo::TPCGeo::DistanceFromReferencePlane

double DistanceFromReferencePlane(geo::Point_t const &point) const

Returns the distance of the specified point from reference plane.

Definition: TPCGeo.h:404

geo::vect::toPoint

::geo::Point_t toPoint(Point const &p)

Convert the specified point into a geo::Point_t.

Definition: geo_vectors_utils.h:1280

template<typename Vector >

Vector geo::TPCGeo::DriftDir ( ) const

Returns the direction of the drift (vector pointing toward the planes).

Definition at line 773 of file TPCGeo.h.

774 { return geo::vect::convertTo<Vector>(fDriftDir); }

geo::TPCGeo::fDriftDir

geo::Vector_t fDriftDir

Direction electrons drift along.

Definition: TPCGeo.h:733

DefaultVector_t geo::TPCGeo::DriftDir ( ) const

inline

Returns the direction of the drift (vector pointing toward the planes).

Definition at line 151 of file TPCGeo.h.

151 { return DriftDir<DefaultVector_t>(); }

DriftDirection_t geo::TPCGeo::DriftDirection ( ) const

inline

Returns an enumerator value describing the drift direction.

Definition at line 144 of file TPCGeo.h.

144 { return fDriftDirection; }

geo::TPCGeo::fDriftDirection

DriftDirection_t fDriftDirection

Direction of the electron drift in the TPC.

Definition: TPCGeo.h:718

double geo::TPCGeo::DriftDistance ( ) const

inline

Drift distance is defined as the distance between the last anode plane and the opposite face of the TPC, in centimeters.

Definition at line 155 of file TPCGeo.h.

155 { return ComputeDriftDistance(); }

geo::TPCGeo::ComputeDriftDistance

double ComputeDriftDistance() const

Definition: TPCGeo.cxx:450

void geo::TPCGeo::DriftPoint	(	geo::Point_t &	position,
		double	distance
	)		const

inline

Shifts the position of an electron drifted by a distance.

Parameters

position	_(modified)_ the position of the electron
distance	drift distance to shift the electron by [cm]

See also: geo::Plane::DriftPoint(), ReferencePlane()

This operation is delegated to the reference plane (see geo::Plane::DriftPoint()).

Definition at line 421 of file TPCGeo.h.

422 { ReferencePlane().DriftPoint(position, distance); }

MakeVectorFile.position

position

Definition: MakeVectorFile.py:80

geo::PlaneGeo::DriftPoint

void DriftPoint(geo::Point_t &position, double distance) const

Shifts the position of an electron drifted by a distance.

Definition: PlaneGeo.h:643

double distance(double x1, double y1, double z1, double x2, double y2, double z2)

Definition: truepionXsection_module.cc:217

geo::PlaneGeo::DriftPoint

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

void geo::TPCGeo::DriftPoint	(	TVector3 &	position,
		double	distance
	)		const

inline

Definition at line 423 of file TPCGeo.h.

424 { ReferencePlane().DriftPoint(position, distance); }

MakeVectorFile.position

position

Definition: MakeVectorFile.py:80

void DriftPoint(geo::Point_t &position, double distance) const

Shifts the position of an electron drifted by a distance.

Definition: PlaneGeo.h:643

double distance(double x1, double y1, double z1, double x2, double y2, double z2)

Definition: truepionXsection_module.cc:217

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

void geo::TPCGeo::FindPlane	(	GeoNodePath_t &	path,
		size_t	depth
	)

private

geo::PlaneGeo const& geo::TPCGeo::FirstPlane ( ) const

inline

Returns the first wire plane (the closest to TPC center).

Definition at line 245 of file TPCGeo.h.

245 { return fPlanes[0]; }

geo::TPCGeo::fActiveCenter

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

template<typename Point >

Point geo::TPCGeo::GetActiveVolumeCenter ( ) const

inline

Returns the center of the TPC active volume in world coordinates [cm].

Definition at line 288 of file TPCGeo.h.

289 { return geo::vect::convertTo<Point>(fActiveCenter); }

geo::Point_t fActiveCenter

Center of the active volume, in world coordinates [cm].

Definition: TPCGeo.h:721

DefaultPoint_t geo::TPCGeo::GetActiveVolumeCenter ( ) const

inline

Returns the center of the TPC active volume in world coordinates [cm].

Definition at line 292 of file TPCGeo.h.

293 { return GetActiveVolumeCenter<DefaultPoint_t>(); }

template<typename Point >

Point geo::TPCGeo::GetCathodeCenter ( ) const

inline

Returns the center of the active volume face opposite to the wire planes [cm]

Definition at line 298 of file TPCGeo.h.

299 { return geo::vect::convertTo<Point>(GetCathodeCenterImpl()); }

geo::TPCGeo::GetCathodeCenterImpl

geo::Point_t GetCathodeCenterImpl() const

Definition: TPCGeo.cxx:330

DefaultPoint_t geo::TPCGeo::GetCathodeCenter ( ) const

inline

Returns the center of the active volume face opposite to the wire planes [cm]

Definition at line 303 of file TPCGeo.h.

304 { return GetCathodeCenter<DefaultPoint_t>(); }

geo::Point_t geo::TPCGeo::GetCathodeCenterImpl ( ) const

private

Definition at line 330 of file TPCGeo.cxx.

                                                 {
 
     //
     // 1. find the center of the face of the TPC opposite to the anode
     // 2. compute the distance of it from the last wire plane
     //
 
     //
     // find the cathode center
     //
     geo::Point_t cathodeCenter = GetActiveVolumeCenter<geo::Point_t>();
     switch (DetectDriftDirection()) {
       case -1:
         geo::vect::Xcoord(cathodeCenter) += ActiveHalfWidth();
       //  cathodeCenter.SetX(cathodeCenter.X() + ActiveHalfWidth());
         break;
       case +1:
         cathodeCenter.SetX(cathodeCenter.X() - ActiveHalfWidth());
         break;
       case -2:
         cathodeCenter.SetY(cathodeCenter.Y() + ActiveHalfHeight());
         break;
       case +2:
         cathodeCenter.SetY(cathodeCenter.Y() - ActiveHalfHeight());
         break;
       case -3:
         cathodeCenter.SetZ(cathodeCenter.Z() + ActiveLength() / 2.0);
         break;
       case +3:
         cathodeCenter.SetZ(cathodeCenter.Z() - ActiveLength() / 2.0);
         break;
       case 0:
       default:
         // in this case, a better algorithm is probably needed
         throw cet::exception("TPCGeo")
           << "CathodeCenter(): Can't determine the cathode plane (code="
           << DetectDriftDirection() << ")\n";
     } // switch
     return cathodeCenter;
 
   } // TPCGeo::GetCathodeCenterImpl()

template<typename Point >

Point geo::TPCGeo::GetCenter ( ) const

Returns the center of the TPC volume in world coordinates [cm].

Definition at line 779 of file TPCGeo.h.

                                  {
 
   // convert the origin (default constructed TVector)
   return geo::vect::convertTo<Point>(toWorldCoords(LocalPoint_t{ 0.0, 0.0, 0.0 }));
 
 } // geo::TPCGeo::GetCenter()

DefaultPoint_t geo::TPCGeo::GetCenter ( ) const

inline

Returns the center of the TPC volume in world coordinates [cm].

Definition at line 284 of file TPCGeo.h.

284 { return GetCenter<DefaultPoint_t>(); }

const PlaneGeo& geo::TPCGeo::GetElement ( PlaneID const & planeid ) const

inline

Definition at line 214 of file TPCGeo.h.

215 { return Plane(planeid); }

geo::TPCGeo::Plane

PlaneGeo const & Plane(geo::View_t view) const

Return the plane in the tpc with View_t view.

Definition: TPCGeo.cxx:263

PlaneGeo const* geo::TPCGeo::GetElementPtr ( PlaneID const & planeid ) const

inline

Definition at line 237 of file TPCGeo.h.

238 { return PlanePtr(planeid); }

geo::TPCGeo::PlanePtr

PlaneGeo const * PlanePtr(unsigned int iplane) const

Returns the plane number iplane from this TPC.

Definition: TPCGeo.h:223

template<typename Point >

Point geo::TPCGeo::GetFrontFaceCenter ( ) const

inline

Returns the center of the active TPC volume side facing negative z.

Definition at line 308 of file TPCGeo.h.

309 { return geo::vect::convertTo<Point>(GetFrontFaceCenterImpl()); }

geo::TPCGeo::GetFrontFaceCenterImpl

geo::Point_t GetFrontFaceCenterImpl() const

Definition: TPCGeo.cxx:374

geo::Point_t geo::TPCGeo::GetFrontFaceCenter ( ) const

inline

Returns the center of the active TPC volume side facing negative z.

Definition at line 312 of file TPCGeo.h.

313 { return GetFrontFaceCenter<geo::Point_t>(); }

geo::Point_t geo::TPCGeo::GetFrontFaceCenterImpl ( ) const

private

Definition at line 374 of file TPCGeo.cxx.

                                                   {
     auto const& activeBox = ActiveBoundingBox();
     return { activeBox.CenterX(), activeBox.CenterY(), activeBox.MinZ() };
   } // TPCGeo::GetFrontFaceCenterImpl()

double geo::TPCGeo::HalfHeight ( ) const

inline

Height is associated with y coordinate [cm].

Definition at line 111 of file TPCGeo.h.

111 { return fHalfHeight; }

geo::TPCGeo::fHalfHeight

double fHalfHeight

Half height of total volume.

Definition: TPCGeo.h:727

double geo::TPCGeo::HalfLength ( ) const

inline

Length is associated with z coordinate [cm].

Definition at line 117 of file TPCGeo.h.

117 { return fLength / 2.0; }

geo::TPCGeo::fLength

double fLength

Length of total volume.

Definition: TPCGeo.h:728

double geo::TPCGeo::HalfWidth ( ) const

inline

Width is associated with x coordinate [cm].

Definition at line 107 of file TPCGeo.h.

107 { return fHalfWidth; }

geo::TPCGeo::fHalfWidth

double fHalfWidth

Half width of total volume.

Definition: TPCGeo.h:726

bool geo::TPCGeo::HasElement ( unsigned int iplane ) const

inline

Definition at line 176 of file TPCGeo.h.

176 { return HasPlane(iplane); }

bool HasPlane(unsigned int iplane) const

Returns whether a plane with index iplane is present in this TPC.

Definition: TPCGeo.h:175

bool geo::TPCGeo::HasElement ( geo::PlaneID const & planeid ) const

inline

Definition at line 190 of file TPCGeo.h.

191 { return HasPlane(planeid); }

bool HasPlane(unsigned int iplane) const

Returns whether a plane with index iplane is present in this TPC.

Definition: TPCGeo.h:175

bool geo::TPCGeo::HasPlane ( unsigned int iplane ) const

inline

Returns whether a plane with index iplane is present in this TPC.

Parameters

iplane index of plane in this TPC

Returns: whether the plane with index iplane is present in this TPC

Definition at line 175 of file TPCGeo.h.

175 { return iplane < Nplanes(); }

geo::TPCGeo::Nplanes

unsigned int Nplanes() const

Number of planes in this tpc.

Definition: TPCGeo.h:165

bool geo::TPCGeo::HasPlane ( geo::PlaneID const & planeid ) const

inline

Returns whether the plane in planeid is present in this TPC.

Parameters

planeid full plane ID

Returns: whether the plane in planeid is present in this TPC

The cryostat and TPC numbers in planeid are ignored, as it is ignored whether planeid is invalid.

Definition at line 188 of file TPCGeo.h.

189 { return HasPlane(planeid.Plane); }

bool HasPlane(unsigned int iplane) const

Returns whether a plane with index iplane is present in this TPC.

Definition: TPCGeo.h:175

double geo::TPCGeo::Height ( ) const

inline

Height is associated with y coordinate [cm].

Definition at line 113 of file TPCGeo.h.

113 { return 2.0 * HalfHeight(); }

geo::TPCGeo::HalfHeight

double HalfHeight() const

Height is associated with y coordinate [cm].

Definition: TPCGeo.h:111

template<typename Vector >

decltype(auto) geo::TPCGeo::HeightDir ( ) const

inline

Returns the direction Height() is measured on.

Definition at line 131 of file TPCGeo.h.

131 { return geo::vect::convertTo<Vector>(fHeightDir); }

geo::TPCGeo::fHeightDir

geo::Vector_t fHeightDir

Direction height refers to.

Definition: TPCGeo.h:731

decltype(auto) geo::TPCGeo::HeightDir ( ) const

inline

Returns the direction Height() is measured on.

Definition at line 134 of file TPCGeo.h.

134 { return HeightDir<DefaultVector_t>(); }

geo::TPCID const& geo::TPCGeo::ID ( ) const

inline

Returns the identifier of this TPC.

Definition at line 333 of file TPCGeo.h.

333 { return fID; }

geo::TPCGeo::fID

geo::TPCID fID

ID of this TPC.

Definition: TPCGeo.h:737

void geo::TPCGeo::InitTPCBoundaries ( )

private

Recomputes the TPC boundary.

Definition at line 464 of file TPCGeo.cxx.

                                  {
     // note that this assumes no rotations of the TPC
     // (except for rotations of a flat angle around one of the three main axes);
     // to avoid this, we should transform the six vertices
     // rather than just the centre
 
     // we rely on the asumption that the center of TPC is at the local origin
     SetBoundaries(
       toWorldCoords(LocalPoint_t(-HalfWidth(), -HalfHeight(), -HalfLength())),
       toWorldCoords(LocalPoint_t(+HalfWidth(), +HalfHeight(), +HalfLength()))
       );
 
     // the center of the active volume may be elsewhere than the local origin:
     auto const& activeCenter = GetActiveVolumeCenter<geo::Point_t>();
     fActiveBox.SetBoundaries(
       activeCenter.X() - ActiveHalfWidth(),  activeCenter.X() + ActiveHalfWidth(),
       activeCenter.Y() - ActiveHalfHeight(), activeCenter.Y() + ActiveHalfHeight(),
       activeCenter.Z() - ActiveHalfLength(), activeCenter.Z() + ActiveHalfLength()
       );
 
 
   } // CryostatGeo::InitTPCBoundaries()

auto geo::TPCGeo::IterateElements ( ) const

Returns an object for iterating through all geo::PlaneGeo.

Returns: an (undisclosed) object for iterating through all geo::PlaneGeo

For example, this snippet computes MaxWires() of TPC (a TPCGeo):

unsigned int maxWires = 0U;
for (geo::PlaneGeo const& plane: TPC.IteratePlanes())
  maxWires = std::max(maxWires, plane.Nwires());

The resulting sequence exposes the planes within the TPC in their ID order, from plane 0 to Nplanes() - 1.

Definition at line 308 of file TPCGeo.cxx.

309 { return fPlanes; }

geo::TPCGeo::IterateElements

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

ElementIteratorBox geo::TPCGeo::IteratePlanes ( ) const

inline

Definition at line 268 of file TPCGeo.h.

268 { return IterateElements(); }

ElementIteratorBox IterateElements() const

Returns an object for iterating through all geo::PlaneGeo.

Definition: TPCGeo.cxx:308

geo::PlaneGeo const& geo::TPCGeo::LastPlane ( ) const

inline

Returns the last wire plane (the farther from TPC center).

Definition at line 248 of file TPCGeo.h.

248 { return fPlanes[Nplanes() - 1]; }

geo::TPCGeo::Nplanes

unsigned int Nplanes() const

Number of planes in this tpc.

Definition: TPCGeo.h:165

geo::LocalTransformation::LocalToWorld

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

double geo::TPCGeo::Length ( ) const

inline

Length is associated with z coordinate [cm].

Definition at line 115 of file TPCGeo.h.

115 { return fLength; }

geo::TPCGeo::fLength

double fLength

Length of total volume.

Definition: TPCGeo.h:728

template<typename Vector >

decltype(auto) geo::TPCGeo::LengthDir ( ) const

inline

Returns the direction Length() is measured on.

Definition at line 138 of file TPCGeo.h.

138 { return geo::vect::convertTo<Vector>(fLengthDir); }

geo::TPCGeo::fLengthDir

geo::Vector_t fLengthDir

Direction length refers to.

Definition: TPCGeo.h:732

decltype(auto) geo::TPCGeo::LengthDir ( ) const

inline

Returns the direction Length() is measured on.

Definition at line 141 of file TPCGeo.h.

141 { return LengthDir<DefaultVector_t>(); }

void geo::TPCGeo::LocalToWorld	(	const double *	tpc,
		double *	world
	)		const

inline

Transform point from local TPC frame to world frame.

Definition at line 563 of file TPCGeo.h.

564 { fTrans.LocalToWorld(tpc, world); }

void LocalToWorld(double const *local, double *world) const

Transforms a point from local frame to world frame.

geo::LocalTransformation::LocalToWorld

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

TVector3 geo::TPCGeo::LocalToWorld ( const TVector3 & local ) const

inline

Transform point from local TPC frame to world frame.

Definition at line 567 of file TPCGeo.h.

568 { return fTrans.LocalToWorld<TVector3>(local); }

void LocalToWorld(double const *local, double *world) const

Transforms a point from local frame to world frame.

geo::LocalTransformation::LocalToWorldVect

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

void geo::TPCGeo::LocalToWorldVect	(	const double *	tpc,
		double *	world
	)		const

inline

Transform direction vector from local to world.

Definition at line 575 of file TPCGeo.h.

576 { fTrans.LocalToWorldVect(tpc, world); }

void LocalToWorldVect(double const *local, double *world) const

Transforms a vector from local frame to world frame.

geo::LocalTransformation::LocalToWorldVect

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

TVector3 geo::TPCGeo::LocalToWorldVect ( const TVector3 & local ) const

inline

Transform direction vector from local to world.

Definition at line 579 of file TPCGeo.h.

580 { return fTrans.LocalToWorldVect<TVector3>(local); }

void LocalToWorldVect(double const *local, double *world) const

Transforms a vector from local frame to world frame.

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

void geo::TPCGeo::MakePlane	(	GeoNodePath_t &	path,
		size_t	depth
	)

private

unsigned int geo::TPCGeo::MaxWires ( ) const

Returns the largest number of wires among the planes in this TPC.

Definition at line 297 of file TPCGeo.cxx.

                                       {
     unsigned int maxWires = 0;
     for (geo::PlaneGeo const& plane: fPlanes) {
       unsigned int maxWiresInPlane = plane.Nwires();
       if (maxWiresInPlane > maxWires) maxWires = maxWiresInPlane;
     } // for
     return maxWires;
   } // TPCGeo::MaxWires()

unsigned int geo::TPCGeo::NElements ( ) const

inline

Definition at line 166 of file TPCGeo.h.

166 { return fPlanes.size(); }

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

unsigned int geo::TPCGeo::Nplanes ( ) const

inline

Number of planes in this tpc.

Definition at line 165 of file TPCGeo.h.

165 { return fPlanes.size(); }

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

const PlaneGeo & geo::TPCGeo::Plane ( geo::View_t view ) const

Return the plane in the tpc with View_t view.

Definition at line 263 of file TPCGeo.cxx.

   {
     geo::PlaneID::PlaneID_t const p = fViewToPlaneNumber[size_t(view)];
     if (p == geo::PlaneID::InvalidID) {
       throw cet::exception("TPCGeo")
         << "TPCGeo[" << ((void*) this) << "]::Plane(): no plane for view #"
         << (size_t) view << "\n";
     }
     return fPlanes[p];
   } // TPCGeo::Plane(geo::View_t)

const PlaneGeo & geo::TPCGeo::Plane ( unsigned int iplane ) const

Return the iplane'th plane in the TPC.

Exceptions

cet::exception (category "PlaneOutOfRange") if no such plane

Definition at line 252 of file TPCGeo.cxx.

   {
     geo::PlaneGeo const* pPlane = PlanePtr(iplane);
     if (!pPlane){
       throw cet::exception("PlaneOutOfRange") << "Request for non-existant plane " << iplane << "\n";
     }
 
     return *pPlane;
   }

const PlaneGeo& geo::TPCGeo::Plane ( PlaneID const & planeid ) const

inline

Returns the plane in planeid from this TPC.

Parameters

planeid full plane ID

Returns: a constant reference to the plane in planeid

Exceptions

cet::exception (category "PlaneOutOfRange") if no such plane

The cryostat and TPC numbers in planeid are ignored, as it is ignored whether planeid is invalid.

Definition at line 212 of file TPCGeo.h.

213 { return Plane(planeid.Plane); }

geo::TPCGeo::Plane

PlaneGeo const & Plane(geo::View_t view) const

Return the plane in the tpc with View_t view.

Definition: TPCGeo.cxx:263

double geo::TPCGeo::Plane0Pitch ( unsigned int p ) const

Definition at line 324 of file TPCGeo.cxx.

   {
     return fPlane0Pitch[p];
   }

const double * geo::TPCGeo::PlaneLocation ( unsigned int p ) const

Returns the coordinates of the center of the specified plane [cm]

Deprecated:: Use Plane(p).GetCenter() or equivalent.

Definition at line 382 of file TPCGeo.cxx.

   {
     return &fPlaneLocation[p][0];
   }

double geo::TPCGeo::PlanePitch	(	unsigned int	p1 = `0`,
		unsigned int	p2 = `1`
	)		const

Definition at line 388 of file TPCGeo.cxx.

   {
     return std::abs(fPlane0Pitch[p2] - fPlane0Pitch[p1]);
   }

PlaneGeo const* geo::TPCGeo::PlanePtr ( unsigned int iplane ) const

inline

Returns the plane number iplane from this TPC.

Parameters

iplane the number of local plane

Returns: a constant pointer to the plane, or nullptr if it does not exist

Definition at line 223 of file TPCGeo.h.

224 { return HasPlane(iplane)? &(fPlanes[iplane]): nullptr; }

bool HasPlane(unsigned int iplane) const

Returns whether a plane with index iplane is present in this TPC.

Definition: TPCGeo.h:175

PlaneCollection_t fPlanes

List of planes in this plane.

Definition: TPCGeo.h:715

PlaneGeo const* geo::TPCGeo::PlanePtr ( PlaneID const & planeid ) const

inline

Returns the plane in planeid from this TPC.

Parameters

planeid full plane ID

Returns: a constant pointer to the plane, or nullptr if it does not exist

The cryostat and TPC numbers in planeid are ignored, as it is ignored whether planeid is invalid.

Definition at line 235 of file TPCGeo.h.

236 { return PlanePtr(planeid.Plane); }

geo::TPCGeo::PlanePtr

PlaneGeo const * PlanePtr(unsigned int iplane) const

Returns the plane number iplane from this TPC.

Definition: TPCGeo.h:223

Projection_t geo::TPCGeo::PointProjection ( geo::Point_t const & point ) const

inline

Definition at line 482 of file TPCGeo.h.

483 { return Projection(point); }

Projection_t Projection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: TPCGeo.h:480

Projection_t geo::TPCGeo::PointProjection ( TVector3 const & point ) const

inline

Definition at line 484 of file TPCGeo.h.

485 { return Projection(geo::vect::toPoint(point)); }

geo::vect::toPoint

::geo::Point_t toPoint(Point const &p)

Convert the specified point into a geo::Point_t.

Definition: geo_vectors_utils.h:1280

geo::PlaneGeo::PointWidthDepthProjection

Projection_t Projection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: TPCGeo.h:480

template<typename Stream >

void geo::TPCGeo::PrintTPCInfo	(	Stream &&	out,
		std::string	indent = `""`,
		unsigned int	verbosity = `1`
	)		const

Prints information about this TPC.

Template Parameters

Stream type of output stream to use

Parameters

out	stream to send the information to
indent	prepend each line with this string
verbosity	amount of information printed

Note that the first line out the output is not indented.

Verbosity levels

0: only TPC ID
1 _(default)_: also center and size
2: also drift direction, cathode position and number of planes
3: also maximum number of wires per plane
4: also information on main direction
5: also information on bounding box

The constant MaxVerbosity is set to the highest supported verbosity level.

Definition at line 789 of file TPCGeo.h.

         {
 
   //----------------------------------------------------------------------------
   out << "TPC " << std::string(ID());
 
   if (verbosity-- <= 0) return; // 0
 
   //----------------------------------------------------------------------------
   out
     << " (" << Width() << " x " << Height() << " x " << Length() << ") cm^3 at "
       << GetCenter<geo::Point_t>();
 
   if (verbosity-- <= 0) return; // 1
 
   //----------------------------------------------------------------------------
 
   out << "\n" << indent
     << "drift direction " << DriftDir<geo::Vector_t>()
       << " from cathode around " << GetCathodeCenter<geo::Point_t>()
       << " through " << DriftDistance() << " cm toward "
       << Nplanes() << " wire planes"
     ;
 
   if (verbosity-- <= 0) return; // 2
 
   //----------------------------------------------------------------------------
   out << "\n" << indent
     << "maximum wires on any plane: " << MaxWires();
 
   if (verbosity-- <= 0) return; // 3
 
   //----------------------------------------------------------------------------
   out << "\n" << indent
     << "active volume ("
       << ActiveWidth() << " x " << ActiveHeight() << " x " << ActiveLength()
       << ") cm^3, front face at " << GetFrontFaceCenter<geo::Point_t>()
       << " cm;"
     << "\n" << indent << "main directions:"
       << " width " << WidthDir<geo::Vector_t>()
       << " height " << HeightDir<geo::Vector_t>()
       << " length " << LengthDir<geo::Vector_t>()
     ;
 
   if (verbosity-- <= 0) return; // 4
 
   //----------------------------------------------------------------------------
   // print also the containing box
   geo::BoxBoundedGeo const& box = BoundingBox();
   out << "\n" << indent
     << "bounding box: " << box.Min() << " -- " << box.Max();
 
 //  if (verbosity-- <= 0) return; // 5
 
   //----------------------------------------------------------------------------
   // print also the active box
   geo::BoxBoundedGeo const& activeBox = ActiveBoundingBox();
   out << "\n" << indent
     << "active volume box: " << activeBox.Min() << " -- "  << activeBox.Max();
 
 //  if (verbosity-- <= 0) return; // 6
 
   //----------------------------------------------------------------------------
 } // geo::TPCGeo::PrintTPCInfo()

Projection_t geo::TPCGeo::Projection ( geo::Point_t const & point ) const

inline

Returns the projection of the specified point on the plane.

Parameters

point the 3D point to be projected, in world coordinates

Returns: a 2D vector representing the projection of point on the plane

The returned vector is a 2D vector expressing the projection of the point (from world coordinates) on the reference plane. The vector is expressed as $ ( w, d ) $ , components following the width direction (RefWidthDir()) and the depth direction (RefDepthDir()) respectively. The origin point is returned by ProjectionReferencePoint(). All coordinates are in centimeters.

Definition at line 480 of file TPCGeo.h.

481 { return ReferencePlane().PointWidthDepthProjection(point); }

WidthDepthProjection_t PointWidthDepthProjection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: PlaneGeo.h:1107

geo::PlaneGeo::VectorWidthDepthProjection

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

Projection_t geo::TPCGeo::Projection ( geo::Vector_t const & v ) const

inline

Returns the projection of the specified vector on the plane.

Parameters

v	the 3D vector to be projected, in world units [cm]

Returns: a 2D vector representing the projection of v on the plane

The returned vector is a 2D vector expressing the projection of the vector (from world units) on the reference plane. The vector is expressed as $ ( w, d ) $ , components following the width direction (RefWidthDir()) and the depth direction (RefDepthDir()) respectively. All coordinates are in centimeters.

Definition at line 501 of file TPCGeo.h.

502 { return ReferencePlane().VectorWidthDepthProjection(v); }

WidthDepthProjection_t VectorWidthDepthProjection(geo::Vector_t const &v) const

Returns the projection of the specified vector on the plane.

Definition: PlaneGeo.h:1127

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

template<typename Point >

Point geo::TPCGeo::ProjectionReferencePoint ( ) const

inline

Returns the reference point used by PointProjection().

Template Parameters

Point type of point to be returned

The returned point is such that its decomposition results in a null projection and a 0 distance from the plane.

Definition at line 460 of file TPCGeo.h.

461 { return ReferencePlane().GetCenter<Point>(); }

geo::PlaneGeo::GetCenter

Point GetCenter() const

Returns the centre of the wire plane in world coordinates [cm].

Definition: PlaneGeo.h:479

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

Point

Definition: HitHandScan_module.cc:39

DefaultPoint_t geo::TPCGeo::ProjectionReferencePoint ( ) const

inline

Definition at line 462 of file TPCGeo.h.

463 { return ProjectionReferencePoint<DefaultPoint_t>(); }

template<typename Vector >

Vector geo::TPCGeo::RefDepthDir ( ) const

inline

Return the direction of reference plane depth.

Template Parameters

Vector type of vector to return (current default: TVector3)

See also: RefWidthDir(), DriftDir()

The precise definition of the vector is arbitrary, but it is defined to lie on the wire plane and so that RefWidthDir(), RefDepthDir() and a vector opposite to DriftDir() make a orthonormal base. That base (width, depth, normal) is guaranteed to be positive defined.

Definition at line 388 of file TPCGeo.h.

388 { return ReferencePlane().DepthDir<Vector>(); }

vector

Definition: lodepng.cpp:52

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

geo::PlaneGeo::DepthDir

Vector DepthDir() const

Return the direction of plane depth.

Definition: PlaneGeo.h:236

DefaultPoint_t geo::TPCGeo::RefDepthDir ( ) const

inline

Definition at line 389 of file TPCGeo.h.

389 { return RefDepthDir<DefaultPoint_t>(); }

geo::PlaneGeo const& geo::TPCGeo::ReferencePlane ( ) const

inline

Returns the plane used for reference by projection methods.

Definition at line 354 of file TPCGeo.h.

354 { return FirstPlane(); }

geo::TPCGeo::FirstPlane

geo::PlaneGeo const & FirstPlane() const

Returns the first wire plane (the closest to TPC center).

Definition: TPCGeo.h:245

geo::PlaneID const& geo::TPCGeo::ReferencePlaneID ( ) const

inline

Returns the ID of the plane used for reference by projection methods.

Definition at line 357 of file TPCGeo.h.

358 { return ReferencePlane().ID(); }

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

geo::PlaneGeo::ID

geo::PlaneID const & ID() const

Returns the identifier of this plane.

Definition: PlaneGeo.h:203

template<typename Vector >

Vector geo::TPCGeo::RefWidthDir ( ) const

inline

Return the direction of reference plane width.

Template Parameters

Vector type of vector to return (current default: TVector3)

See also: RefDepthDir(), DriftDir()

The precise definition of the vector is arbitrary, but it is defined to lie on the wire plane and so that RefWidthDir(), RefDepthDir() and a vector opposite to DriftDir() make a orthonormal base. That base (width, depth, normal) is guaranteed to be positive defined.

Definition at line 372 of file TPCGeo.h.

372 { return ReferencePlane().WidthDir<Vector>(); }

vector

Definition: lodepng.cpp:52

geo::LocalTransformationGeo::toLocalCoords

geo::PlaneGeo const & ReferencePlane() const

Returns the plane used for reference by projection methods.

Definition: TPCGeo.h:354

geo::PlaneGeo::WidthDir

Vector WidthDir() const

Return the direction of plane width.

Definition: PlaneGeo.h:221

DefaultPoint_t geo::TPCGeo::RefWidthDir ( ) const

inline

Definition at line 373 of file TPCGeo.h.

373 { return RefWidthDir<DefaultPoint_t>(); }

void geo::TPCGeo::ResetDriftDirection ( )

private

Recomputes the drift direction; needs planes to have been initialised.

Definition at line 402 of file TPCGeo.cxx.

                                    {
 
     auto const driftDirCode = DetectDriftDirection();
     switch (driftDirCode) {
       case +1:
         fDriftDirection = geo::kPosX; // this is the same as kPos!
         fDriftDir = geo::Xaxis();
         break;
       case -1:
         fDriftDirection = geo::kNegX; // this is the same as kNeg!
         fDriftDir = -geo::Xaxis();
         break;
       case +2:
         fDriftDir = geo::Yaxis();
         fDriftDirection = geo::kPos;
         break;
       case -2:
         fDriftDir = -geo::Yaxis();
         fDriftDirection = geo::kNeg;
         break;
       case +3:
         fDriftDir = geo::Zaxis();
         fDriftDirection = geo::kPos;
         break;
       case -3:
         fDriftDir = -geo::Zaxis();
         fDriftDirection = geo::kNeg;
         break;
       default:
         // TPC ID is likely not yet set
         fDriftDirection = kUnknownDrift;
 
         // we estimate the drift direction roughly from the geometry
         fDriftDir = Plane(0).GetBoxCenter() - GetCenter();
 
         mf::LogError("TPCGeo")
           << "Unable to detect drift direction (result: " << driftDirCode
           << ", drift: ( " << fDriftDir.X() << " ; " << fDriftDir.Y() << " ; "
           << fDriftDir.Z() << " )";
         break;
     } // switch
 
     geo::vect::round01(fDriftDir, 1e-4);
 
   } // TPCGeo::ResetDriftDirection()

geo::PlaneGeo const & geo::TPCGeo::SmallestPlane ( ) const

Returns the wire plane with the smallest surface.

Definition at line 276 of file TPCGeo.cxx.

                                                  {
 
     //
     // Returns the plane with the smallest width x depth. No nonsense here.
     //
 
     auto iPlane = fPlanes.begin(), pend = fPlanes.end();
     auto smallestPlane = iPlane;
     double smallestSurface = smallestPlane->Width() * smallestPlane->Depth();
     while (++iPlane != pend) {
       double const surface = iPlane->Width() * iPlane->Depth();
       if (surface > smallestSurface) continue;
       smallestSurface = surface;
       smallestPlane = iPlane;
     } // while
     return *smallestPlane;
 
   } // TPCGeo::SmallestPlane()

void geo::TPCGeo::SortPlanes ( std::vector< geo::PlaneGeo > & planes ) const

private

Sorts (in place) the specified PlaneGeo objects by drift distance.

Definition at line 529 of file TPCGeo.cxx.

                                                               {
     //
     // Sort planes by increasing drift distance.
     //
     // This function should work in bootstrap mode, relying on least things as
     // possible. Therefore we compute here a proxy of the drift axis.
     //
 
     //
     // determine the drift axis (or close to): from TPC center to plane center
     //
 
     // Instead of using the plane center, which might be not available yet,
     // we use the plane box center, which only needs the geometry description
     // to be available.
     // We use the first plane -- it does not make any difference.
     auto const TPCcenter = GetCenter();
     auto const driftAxis
       = geo::vect::normalize(planes[0].GetBoxCenter() - TPCcenter);
 
     auto by_distance = [&TPCcenter, &driftAxis](auto const& a,
                                                 auto const& b) {
       return geo::vect::dot(a.GetBoxCenter() - TPCcenter, driftAxis) <
              geo::vect::dot(b.GetBoxCenter() - TPCcenter, driftAxis);
     };
     cet::sort_all(planes, by_distance);
 
   } // TPCGeo::SortPlanes()

void geo::TPCGeo::SortSubVolumes ( geo::GeoObjectSorter const & sorter )

Apply sorting to the PlaneGeo objects.

Definition at line 201 of file TPCGeo.cxx.

   {
     SortPlanes(fPlanes);
     
     // the PlaneID_t cast convert InvalidID into a rvalue (non-reference);
     // leaving it a reference would cause C++ to treat it as such,
     // that can't be because InvalidID is a static member constant without an address
     // (it is not defined in any translation unit, just declared in header)
     fViewToPlaneNumber.resize
       (1U + (size_t) geo::kUnknown, (geo::PlaneID::PlaneID_t) geo::PlaneID::InvalidID);
     for(size_t p = 0; p < this->Nplanes(); ++p)
       fViewToPlaneNumber[(size_t) fPlanes[p].View()] = p;
 
     for(size_t p = 0; p < fPlanes.size(); ++p) fPlanes[p].SortWires(sorter);
 
   }

LocalPoint_t geo::TPCGeo::toLocalCoords ( geo::Point_t const & world ) const

inline

Transform point from world frame to local TPC frame.

Definition at line 595 of file TPCGeo.h.

596 { return fTrans.toLocalCoords(world); }

LocalPoint_t toLocalCoords(GlobalPoint_t const &world) const

Transforms a point from world frame to local frame.

Definition: LocalTransformationGeo.h:134

geo::LocalTransformationGeo::toLocalCoords

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

LocalVector_t geo::TPCGeo::toLocalCoords ( geo::Vector_t const & world ) const

inline

Transform direction vector from world to local.

Definition at line 607 of file TPCGeo.h.

608 { return fTrans.toLocalCoords(world); }

LocalPoint_t toLocalCoords(GlobalPoint_t const &world) const

Transforms a point from world frame to local frame.

Definition: LocalTransformationGeo.h:134

geo::TPCGeo::fTotalVolume

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

const TGeoVolume* geo::TPCGeo::TotalVolume ( ) const

inline

Definition at line 120 of file TPCGeo.h.

120 { return fTotalVolume; }

TGeoVolume * fTotalVolume

Total volume of TPC, called volTPC in GDML file.

Definition: TPCGeo.h:717

geo::Point_t geo::TPCGeo::toWorldCoords ( LocalPoint_t const & local ) const

inline

Transform point from local TPC frame to world frame.

Definition at line 571 of file TPCGeo.h.

572 { return fTrans.toWorldCoords(local); }

geo::LocalTransformationGeo::toWorldCoords

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:104

geo::Vector_t geo::TPCGeo::toWorldCoords ( LocalVector_t const & local ) const

inline

Transform direction vector from local to world.

Definition at line 583 of file TPCGeo.h.

584 { return fTrans.toWorldCoords(local); }

geo::LocalTransformationGeo::toWorldCoords

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:104

std::string geo::TPCGeo::TPCInfo	(	std::string	indent = `""`,
		unsigned int	verbosity = `1`
	)		const

Returns a string with information about this TPC.

See also: PrintTPCInfo()

Arguments and provided information are the same as in PrintTPCInfo().

Definition at line 244 of file TPCGeo.cxx.

   {
     std::ostringstream sstr;
     PrintTPCInfo(sstr, indent, verbosity);
     return sstr.str();
   } // TPCGeo::TPCInfo()

void geo::TPCGeo::UpdateAfterSorting ( geo::TPCID tpcid )

Performs all updates after cryostat has sorted TPCs.

Definition at line 220 of file TPCGeo.cxx.

                                                 {
 
     // reset the ID
     fID = tpcid;
 
     // ask the planes to update; also check
 
     for (unsigned int plane = 0; plane < Nplanes(); ++plane) {
       fPlanes[plane].UpdateAfterSorting(geo::PlaneID(fID, plane), *this);
 
       // check that the plane normal is opposite to the TPC drift direction
       assert(lar::util::makeVector3DComparison(1e-5)
         .equal(-(fPlanes[plane].GetNormalDirection()), DriftDir()));
 
     } // for
 
     UpdatePlaneCache();
     UpdatePlaneViewCache();
 
   } // TPCGeo::UpdateAfterSorting()

void geo::TPCGeo::UpdatePlaneCache ( )

private

Updates plane cached information.

Definition at line 506 of file TPCGeo.cxx.

                                 {
 
     /*
      * set the plane pitch for this TPC
      */
     fPlaneLocation.resize(fPlanes.size());
     fPlane0Pitch.resize(Nplanes(), 0.);
     geo::Point_t refPlaneCenter = fPlanes[0].GetCenter<geo::Point_t>();
     for(size_t p = 0; p < Nplanes(); ++p){
       geo::Point_t const& center = fPlanes[p].GetCenter<geo::Point_t>();
       fPlane0Pitch[p] = (p == 0)
         ? 0.0
         : fPlane0Pitch[p-1] + std::abs(center.X()-refPlaneCenter.X())
         ;
       fPlaneLocation[p].resize(3);
       geo::vect::fillCoords(fPlaneLocation[p], center);
       refPlaneCenter = center;
     } // for planes
 
   } // TPCGeo::UpdatePlaneViewCache()

void geo::TPCGeo::UpdatePlaneViewCache ( )

private

Refills the plane vs. view cache of the TPC.

Definition at line 489 of file TPCGeo.cxx.

                                     {
 
     // the PlaneID_t cast convert InvalidID into a rvalue (non-reference);
     // leaving it a reference would cause C++ to treat it as such,
     // that can't be because InvalidID is a static member constant without an address
     // (it is not defined in any translation unit, just declared in header)
     fViewToPlaneNumber.clear();
     fViewToPlaneNumber.resize
       (1U + (size_t) geo::kUnknown, (geo::PlaneID::PlaneID_t) geo::PlaneID::InvalidID);
     for(size_t p = 0; p < Nplanes(); ++p)
       fViewToPlaneNumber[(size_t) fPlanes[p].View()] = p;
 
   } // TPCGeo::UpdatePlaneViewCache()

Projection_t geo::TPCGeo::VectorProjection ( geo::Vector_t const & v ) const

inline

Definition at line 503 of file TPCGeo.h.

504 { return Projection(v); }

Projection_t Projection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: TPCGeo.h:480

Projection_t geo::TPCGeo::VectorProjection ( TVector3 const & v ) const

inline

Definition at line 505 of file TPCGeo.h.

506 { return Projection(geo::vect::toVector(v)); }

geo::vect::toVector

::geo::Vector_t toVector(Vector const &v)

Convert the specified vector into a geo::Vector_t.

Definition: geo_vectors_utils.h:1285

geo::LocalTransformation::WorldToLocal

Projection_t Projection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: TPCGeo.h:480

std::set< geo::View_t > geo::TPCGeo::Views ( ) const

Returns a set of all views covered in this TPC.

Definition at line 313 of file TPCGeo.cxx.

                                         {
     std::set<geo::View_t> views;
     std::transform(fPlanes.cbegin(), fPlanes.cend(),
       std::inserter(views, views.begin()), std::mem_fn(&geo::PlaneGeo::View));
     return views;
   } // TPCGeo::Views()

double geo::TPCGeo::Width ( ) const

inline

Width is associated with x coordinate [cm].

Definition at line 109 of file TPCGeo.h.

109 { return 2.0 * HalfWidth(); }

geo::TPCGeo::HalfWidth

double HalfWidth() const

Width is associated with x coordinate [cm].

Definition: TPCGeo.h:107

template<typename Vector >

decltype(auto) geo::TPCGeo::WidthDir ( ) const

inline

Returns the direction Width() is measured on.

Definition at line 124 of file TPCGeo.h.

124 { return geo::vect::convertTo<Vector>(fWidthDir); }

geo::TPCGeo::fWidthDir

geo::Vector_t fWidthDir

Direction width refers to.

Definition: TPCGeo.h:730

decltype(auto) geo::TPCGeo::WidthDir ( ) const

inline

Returns the direction Width() is measured on.

Definition at line 127 of file TPCGeo.h.

127 { return WidthDir<DefaultVector_t>(); }

double geo::TPCGeo::WirePitch ( unsigned plane = 0 ) const

Definition at line 396 of file TPCGeo.cxx.

   {
     return this->Plane(plane).WirePitch();
   }

void geo::TPCGeo::WorldToLocal	(	const double *	world,
		double *	tpc
	)		const

inline

Transform point from world frame to local TPC frame.

Definition at line 587 of file TPCGeo.h.

588 { fTrans.WorldToLocal(world, tpc); }

void WorldToLocal(double const *world, double *local) const

Transforms a point from world frame to local frame.

geo::LocalTransformation::WorldToLocal

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

TVector3 geo::TPCGeo::WorldToLocal ( TVector3 const & world ) const

inline

Transform point from world frame to local TPC frame.

Definition at line 591 of file TPCGeo.h.

592 { return fTrans.WorldToLocal<TVector3>(world); }

void WorldToLocal(double const *world, double *local) const

Transforms a point from world frame to local frame.

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

void geo::TPCGeo::WorldToLocalVect	(	const double *	world,
		double *	tpc
	)		const

inline

Transform direction vector from world to local.

Definition at line 599 of file TPCGeo.h.

600 { fTrans.WorldToLocalVect(world, tpc); }

geo::LocalTransformation::WorldToLocalVect

LocalTransformation_t fTrans

TPC-to-world transformation.

Definition: TPCGeo.h:713

void WorldToLocalVect(const double *world, double *local) const

Transforms a vector from world frame to local frame.

TVector3 geo::TPCGeo::WorldToLocalVect ( TVector3 const & world ) const

inline

Transform direction vector from world to local.

Definition at line 603 of file TPCGeo.h.

604 { return fTrans.WorldToLocalVect<TVector3>(world); }