LArSoft: geo::PlaneGeo Class Reference

geo::PlaneGeo::toWorldCoords

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:403

Point_t geo::PlaneGeo::GetBoxCenter ( ) const

inline

Returns the centre of the box representing the plane.

Returns: the centre of the box, in world coordinates [cm]

See also: GetCenter()

This is the centre of the box representing the plane in the geometry description, in world coordinates. This is rarely of any use, as most of the times GetCenter() delivers the proper information, e.g. for simulation and reconstruction.

Definition at line 380 of file PlaneGeo.h.

References toWorldCoords().

Referenced by geo::GeometryBuilderStandard::makeTPC(), UpdatePlaneNormal(), and UpdateWirePlaneCenter().

380 { return toWorldCoords(LocalPoint_t{0.0, 0.0, 0.0}); }

Point_t toWorldCoords(LocalPoint_t const &local) const

Transform point from local plane frame to world frame.

Definition: PlaneGeo.h:1111

geo::PlaneGeo::LocalPoint_t

Point3DBase_t< PlaneGeoCoordinatesTag > LocalPoint_t

Type of points in the local GDML wire plane frame.

Definition: PlaneGeo.h:94

Point_t const& geo::PlaneGeo::GetCenter ( ) const

inline

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

See also: GetBoxCenter()

The center of the plane is defined so that it has width and depth coordinates in the middle of the plane box (that is, the geometrical representation of the plane in the geometry description), and the other coordinate set at drift distance 0.

Note that this does not necessarily match the center of the box, if the geometry does not place the wires, which define the drift distance, in the plane in the middle of the box.

Definition at line 366 of file PlaneGeo.h.

References fCenter.

Referenced by larg4::LArVoxelReadout::DriftIonizationElectrons(), PrintPlaneInfo(), DUNE::NeutrinoTrackingEff::truthLength(), and UpdateDecompWireOrigin().

366 { return fCenter; }

geo::PlaneGeo::fCenter

Point_t fCenter

Center of the plane, lying on the wire plane.

Definition: PlaneGeo.h:1227

WireGeo const& geo::PlaneGeo::GetElement ( WireID const & wireid ) const

inline

Returns the wire in wireid from this plane.

Parameters

wireid full wire ID

Returns: a constant reference to the wire in wireid

Exceptions

cet::exception (category "WireOutOfRange") if no such wire

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

Definition at line 274 of file PlaneGeo.h.

References Wire().

274 { return Wire(wireid); }

geo::Decomposer::SecondaryDir

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:403

auto geo::PlaneGeo::GetElementPtr ( WireID const & wireid ) const

inline

Returns the wire in wireid from this plane.

Parameters

wireid full wire ID

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

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

Definition at line 294 of file PlaneGeo.h.

References WirePtr().

294 { return WirePtr(wireid); }

geo::PlaneGeo::WirePtr

auto WirePtr(unsigned int iwire) const

Returns the wire number iwire from this plane.

Definition: PlaneGeo.h:282

Vector_t const& geo::PlaneGeo::GetIncreasingWireDirection ( ) const

inline

Returns the direction of increasing wires.

Returns: a TVector3 versor with the direction of increasing wires

The versor is orthogonal to the wires (assumed parallel), lies on the plane and its direction goes toward increasing wire IDs.

Definition at line 350 of file PlaneGeo.h.

References fDecompWire, and geo::Decomposer< Vector, Point, ProjVector >::SecondaryDir().

Referenced by ShowerRecoTools::ShowerTrajPointdEdx::CalculateElement(), PrintPlaneInfo(), shouldFlipWire(), UpdatePhiZ(), and WireIDincreasesWithZ().

350 { return fDecompWire.SecondaryDir(); }

Vector_t const & SecondaryDir() const

Returns the plane secondary axis direction.

Definition: Decomposer.h:453

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1218

Vector_t geo::PlaneGeo::GetNormalAxis ( ) const

private

Returns a direction normal to the plane (pointing is not defined).

Definition at line 676 of file PlaneGeo.cxx.

References geo::WireGeo::Direction(), e, geo::WireGeo::GetCenter(), Nwires(), geo::vect::rounded01(), and Wire().

Referenced by UpdatePlaneNormal(), and Volume().

   {
     unsigned const int NWires = Nwires();
     if (NWires < 2) return {}; // why are we even here?
 
     // 1) get the direction of the middle wire
     auto const WireDir = Wire(NWires / 2).Direction();
 
     // 2) get the direction between the middle wire and the next one
     auto const ToNextWire = Wire(NWires / 2 + 1).GetCenter() - Wire(NWires / 2).GetCenter();
 
     // 3) get the direction perpendicular to the plane
     // 4) round it
     // 5) return its norm
     return vect::rounded01(WireDir.Cross(ToNextWire).Unit(), 1e-4);
   }

Vector_t const& geo::PlaneGeo::GetNormalDirection ( ) const

inline

Returns the direction normal to the plane.

Returns: a TVector3 versor with a direction normal to the plane

The versor is orthogonal to the plane. The direction is defined so that the semi-space pointed to contains the TPC center.

Note: Each decomposition base (wire-based and frame-based) has its own normal, defined solely from its two decomposition plane axes. The wire-based frame is nevertheless required to have a normal matching this one, while the frame-based normal might happen to be in the opposite direction depending on the original geometry description.

Definition at line 339 of file PlaneGeo.h.

References fNormal.

Referenced by DriftPoint(), PrintPlaneInfo(), shouldFlipWire(), UpdateIncreasingWireDir(), UpdateOrientation(), UpdateView(), UpdateWidthDepthDir(), and UpdateWireDir().

339 { return fNormal; }

geo::PlaneGeo::fNormal

Vector_t fNormal

Definition: PlaneGeo.h:1214

Vector_t const& geo::PlaneGeo::GetWireDirection ( ) const

inline

Returns the direction of the wires.

Returns: a unit vector following the direction of the wires

All wires in the plane are assumed parallel.

Definition at line 390 of file PlaneGeo.h.

References ClosestWireID(), fDecompWire, geo::Decomposer< Vector, Point, ProjVector >::MainDir(), NearestWire(), and NearestWireID().

Referenced by PrintPlaneInfo(), lar::util::TrackPitchInView(), and UpdateView().

390 { return fDecompWire.MainDir(); }

geo::Decomposer::MainDir

Vector_t const & MainDir() const

Returns the plane main axis direction.

Definition: Decomposer.h:450

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1218

bool geo::PlaneGeo::HasElement ( unsigned int iwire ) const

inline

Returns whether a wire with index iwire is present in this plane.

Parameters

iwire index of wire in this plane

Returns: whether the wire with index iwire is present in this plane

Definition at line 242 of file PlaneGeo.h.

References HasWire().

242 { return HasWire(iwire); }

bool HasWire(unsigned int iwire) const

Returns whether a wire with index iwire is present in this plane.

Definition: PlaneGeo.h:241

bool geo::PlaneGeo::HasElement ( WireID const & wireid ) const

inline

Returns whether the wire in wireid is present in this plane.

Parameters

wireid full wire ID

Returns: whether the wire in wireid is present in this plane

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

Definition at line 255 of file PlaneGeo.h.

References HasWire(), and Wire().

255 { return HasWire(wireid); }

bool HasWire(unsigned int iwire) const

Returns whether a wire with index iwire is present in this plane.

Definition: PlaneGeo.h:241

bool geo::PlaneGeo::HasWire ( unsigned int iwire ) const

inline

Returns whether a wire with index iwire is present in this plane.

Parameters

iwire index of wire in this plane

Returns: whether the wire with index iwire is present in this plane

Definition at line 241 of file PlaneGeo.h.

References Nwires().

Referenced by HasElement(), geo::WireReadoutGeom::HasWire(), and WirePtr().

241 { return iwire < Nwires(); }

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:231

bool geo::PlaneGeo::HasWire ( WireID const & wireid ) const

inline

Returns whether the wire in wireid is present in this plane.

Parameters

wireid full wire ID

Returns: whether the wire in wireid is present in this plane

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

Definition at line 254 of file PlaneGeo.h.

References HasWire(), and geo::WireID::Wire.

Referenced by HasWire().

254 { return HasWire(wireid.Wire); }

bool HasWire(unsigned int iwire) const

Returns whether a wire with index iwire is present in this plane.

Definition: PlaneGeo.h:241

PlaneID const& geo::PlaneGeo::ID ( ) const

inline

Returns the identifier of this plane.

Definition at line 173 of file PlaneGeo.h.

References fID.

Referenced by ClosestWireID(), detinfo::DetectorPropertiesStandard::DataFor(), geo::WireReadoutDumper::dumpTPCplane(), NearestWire(), NearestWireID(), PrintPlaneInfo(), and lar::util::TrackPitchInView().

173 { return fID; }

geo::PlaneGeo::fID

PlaneID fID

ID of this plane.

Definition: PlaneGeo.h:1229

double geo::PlaneGeo::InterWireDistance ( Vector_t const & dir ) const

Returns the distance between wires along the specified direction.

Parameters

dir	the direction (3D)

Returns: the distance between wires along that direction [cm]

The direction is specified as a 3D vector in the world coordinate frame. The modulus of the vector is ignored but expected to be non null.

The returned distance is the space that would be covered starting from a wire toward the dir direction and stopping when the projection on the wire plane reaches another wire. This distance is returned in centimeters, always positive and not smaller than the wire pitch.

Note: If the direction is too close to the wire direction, the result will be numerically unstable and might be infinite (test with std::isinf(), std::isfinite() or std::isnormal()). It is recommended that the caller take special actions when the result is too large.

Definition at line 538 of file PlaneGeo.cxx.

References util::abs(), e, fDecompWire, fWirePitch, r, and geo::Decomposer< Vector, Point, ProjVector >::VectorSecondaryComponent().

Referenced by DriftPoint().

   {
     // the secondary component of the wire decomposition basis is wire coord.
     double const r = dir.R();
     assert(r >= 1.e-6);
 
     double const absWireCoordProj = std::abs(fDecompWire.VectorSecondaryComponent(dir));
     return r / absWireCoordProj * fWirePitch;
   }

double geo::PlaneGeo::InterWireProjectedDistance ( WireCoordProjection_t const & projDir ) const

Returns the distance between wires along the specified direction.

Parameters

projDir the direction, projected on the plane (2D)

Returns: the distance between wires along that direction [cm]

The direction is specified as a geo::PlaneGeo::WireCoordProjection_t vector, defined as in geo::PlaneGeo::Projection(). The modulus of the projection is ignored but expected to be non null.

The returned distance is the space that would be covered starting from a wire toward the projDir direction and stopping at the first wire met. This distance is returned in centimeters, always positive and not smaller than the wire pitch.

Note: If the direction is too close to the wire direction, the result will be numerically unstable and might be infinite (test with std::isinf(), std::isfinite() or std::isnormal()). It is recommended that the caller take special actions when the result is too large.

Definition at line 531 of file PlaneGeo.cxx.

References e, and fWirePitch.

Referenced by DriftPoint(), and InterWireProjectedDistance().

   {
     assert(lar::util::Vector2DComparison{1e-6}.nonZero(projDir));
     return std::sqrt(cet::square(projDir.X() / projDir.Y()) + 1.0) * fWirePitch;
   }

double geo::PlaneGeo::InterWireProjectedDistance ( Vector_t const & dir ) const

inline

Returns the distance between wires along the specified direction.

Parameters

dir	the direction in detector space (3D)

Returns: the distance between wires along that direction [cm]

See also: InterWireProjectedDistance(geo::PlaneGeo::WireCoordProjection_t const&) const

The direction is specified as a 3D vector. Its modulus is ignored but expected to be non null.

The returned distance is the space that would be covered starting from a wire toward the direction projection of dir on the wire plane, and stopping at the first wire met. This distance is returned in centimeters and always positive.

Note: This is not a 3D distance (for example, it's not useful to compute of a track to get its ionization energy ), but it is the distance projected on the wire plane.

Definition at line 583 of file PlaneGeo.h.

References InterWireProjectedDistance(), and Projection().

     {
       return InterWireProjectedDistance(Projection(dir));
     }

bool geo::PlaneGeo::isProjectionOnPlane ( Point_t const & point ) const

Returns if the projection of specified point is within the plane.

Parameters

point world coordinate of the point to test [cm]

Returns: whether the projection of specified point is within the plane

See also: PointWidthDepthProjection(), Width(), Height()

The method extracts the projection of the specified point on the plane, as in PointWidthDepthProjection(), and then verifies that the projection falls within the wire plane area, as defined by the dimensions from the geometry description.

Definition at line 449 of file PlaneGeo.cxx.

References DeltaFromPlane(), and PointWidthDepthProjection().

Referenced by VectorWidthDepthProjection().

   {
     auto const deltaProj = DeltaFromPlane(PointWidthDepthProjection(point));
     return (deltaProj.X() == 0.) && (deltaProj.Y() == 0.);
   }

WireGeo const& geo::PlaneGeo::LastWire ( ) const

inline

Return the last wire in the plane.

Definition at line 304 of file PlaneGeo.h.

References Nwires(), and Wire().

304 { return Wire(Nwires() - 1); }

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:403

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:231

WireGeo const& geo::PlaneGeo::MiddleWire ( ) const

inline

Return the middle wire in the plane.

Definition at line 301 of file PlaneGeo.h.

References Nwires(), and Wire().

301 { return Wire(Nwires() / 2); }

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:403

Referenced by calo::TrackCalorimetryAlg::ExtractCalorimetry(), util::GeometryUtilities::Get2DPointProjection(), util::GeometryUtilities::Get2DPointProjectionCM(), opdet::GetHitGeometryInfo(), nnet::TrainingDataAlg::getProjection(), GetWireDirection(), apa::APAGeometryAlg::LineSegChanIntersect(), geo::WireReadoutGeom::NearestChannel(), NearestWire(), apa::APAGeometryAlg::NearestWireIDOnChan(), trk::TrackContainmentAlg::ProcessTracks(), and shower::EMShowerAlg::Project3DPointOntoPlane_().

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:231

Point_t geo::PlaneGeo::MovePointOverPlane ( Point_t const & point ) const

Returns the point, moved so that its projection is over the plane.

Parameters

point point to be checked and moved

Returns: the new value of the point

See also: isProjectionOnPlane(), MoveProjectionToPlane(), Width(), Height()

If the projection of the point on the plane falls outside it, the returned point is translated so that its projection is now on the border of the plane. The translation happens along the directions of the plane frame, as described in MoveProjectionToPlane().

Definition at line 475 of file PlaneGeo.cxx.

References DeltaFromPlane(), DepthDir(), PointWidthDepthProjection(), and WidthDir().

Referenced by DeltaFromActivePlane().

   {
     // This implementation is subject to rounding errors, since the result of the addition
     // might jitter above or below the border.
 
     auto const deltaProj = DeltaFromPlane(PointWidthDepthProjection(point));
     return point + deltaProj.X() * WidthDir() + deltaProj.Y() * DepthDir();
   }

PlaneGeo::WidthDepthProjection_t geo::PlaneGeo::MoveProjectionToPlane ( WidthDepthProjection_t const & proj ) const

Returns the projection, moved onto the plane if necessary.

Parameters

proj	projection to be checked and moved

Returns: the new value of the projection

See also: isProjectionOnPlane(), Width(), Height()

The projection proj is defined as in the output of PointWidthDepthProjection(). The method caps width and depth of the projection so that it stays on the plane. A new capped value is returned. Since the reference point of the frame is defined as the center of the plane, this action is equivalent to force the width component in $\left[ -\frac{w}{2}, \frac{w}{2} \right]$ range and the depth component into $\left[ -\frac{d}{2}, \frac{d}{2} \right]$ , with $ w $ and $ d $ the width and depth of the wire plane.

Definition at line 456 of file PlaneGeo.cxx.

References DeltaFromPlane(), fFrameSize, geo::PlaneGeo::RectSpecs::HalfDepth(), and geo::PlaneGeo::RectSpecs::HalfWidth().

Referenced by DeltaFromActivePlane().

   {
     // We have a more complicated implementation to avoid rounding errors.  In this way,
     // the result is really guaranteed to be exactly on the border.
     auto const delta = DeltaFromPlane(proj);
     return {(delta.X() == 0.0) ?
               proj.X() :
               ((delta.X() > 0) ? -fFrameSize.HalfWidth() // delta positive -> proj on negative side
                                  :
                                  fFrameSize.HalfWidth()),
             (delta.Y() == 0.0) ?
               proj.Y() :
               ((delta.Y() > 0) ? -fFrameSize.HalfDepth() // delta positive -> proj on negative side
                                  :
                                  fFrameSize.HalfDepth())};
   }

WireGeo const & geo::PlaneGeo::NearestWire ( Point_t const & pos ) const

Returns the wire closest to the specified position.

Parameters

pos	world coordinates of the point [cm]

Returns: the ID of the wire closest to the projection of pos on the plane

Exceptions

InvalidWireError (category: "Geometry") if out of range

The position is projected on the wire plane, and the nearest wire to the projected point is returned.

If the wire is father than half a wire pitch from the point, an exception is thrown that contains both the wire that would be the closest one (badWireID()), and also the wire that is actually the closest one (betterWireID()). When this happens, the specified position was outside the wire plane.

Note that the caller should check for containment: this function may or may not report the position being outside the plane, depending on where it is. In the current implementation, the wires are considered infinitely long, and if the position projection is closer than half the wire pitch from any of these extrapolated wires, the method will not report error.

Definition at line 514 of file PlaneGeo.cxx.

References ClosestWireID(), ID(), NearestWireID(), Wire(), and geo::WireID::Wire.

Referenced by GetWireDirection().

   {
     // Note that this code is ready for when NearestWireID() will be changed to return an
     // invalid ID instead of throwing.  As things are now, `NearestWireID()` will never
     // return an invalid ID, but it will throw an exception similar to this one.
 
     WireID const wireID = NearestWireID(point);
     if (wireID) return Wire(wireID); // we have that wire, so we return it
 
     // wire ID is invalid, meaning it's out of range. Throw an exception!
     WireID const closestID = ClosestWireID(wireID);
     throw InvalidWireError("Geometry", ID(), closestID.Wire, wireID.Wire)
       << "Can't find nearest wire for position " << point << " in plane " << std::string(ID())
       << " approx wire number # " << closestID.Wire << " (capped from " << wireID.Wire << ")\n";
   }

WireID geo::PlaneGeo::NearestWireID ( Point_t const & pos ) const

Returns the ID of wire closest to the specified position.

Parameters

pos	world coordinates of the point [cm]

Returns: the ID of the wire closest to the projection of pos on the plane

Exceptions

InvalidWireError (category: "Geometry") if out of range

The position is projected on the wire plane, and the ID of the nearest wire to the projected point is returned.

If the wire does not exist, an exception is thrown that contains both the wire that would be the closest one (badWireID()), and also the wire that is actually the closest one (betterWireID()). When this happens, the specified position was outside the wire plane.

Note that the caller should check for containment: this function may or may not report the position being outside the plane, depending on where it is. In the current implementation, the wires are considered infinitely long, and if the position projection is closer than half the wire pitch from any of these extrapolated wires, the method will not report error.

Todo:: When the ID is out of range, instead of throwing an exception, return an invalid wire ID with the wire number set to the non-existing wire which would be the nearest to pos.

Definition at line 485 of file PlaneGeo.cxx.

References ID(), Nwires(), and WireCoordinate().

   {
     // 1) compute the wire coordinate of the point
     // 2) get the closest wire number
     // 3) check if the wire does exist
     // 4) build and return the wire ID
 
     // this line merges parts (1) and (2); add 0.5 to have the correct rounding:
     int nearestWireNo = int(0.5 + WireCoordinate(pos));
 
     // if we are outside of the wireplane range, throw an exception
     if ((nearestWireNo < 0) || ((unsigned int)nearestWireNo >= Nwires())) {
 
       auto wireNo = nearestWireNo; // save for the output
 
       if (nearestWireNo < 0)
         wireNo = 0;
       else
         wireNo = Nwires() - 1;
 
       throw InvalidWireError("Geometry", ID(), nearestWireNo, wireNo)
         << "Can't find nearest wire for position " << pos << " in plane " << std::string(ID())
         << " approx wire number # " << wireNo << " (capped from " << nearestWireNo << ")\n";
     } // if invalid
 
     return {ID(), (WireID::WireID_t)nearestWireNo};
   }

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

inline

Number of wires in this plane.

Definition at line 232 of file PlaneGeo.h.

References Nwires().

Referenced by geo::WireReadoutGeom::Nwires().

232 { return Nwires(); }

geo::PlaneGeo::fOrientation

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:231

unsigned int geo::PlaneGeo::Nwires ( ) const

inline

Number of wires in this plane.

Definition at line 231 of file PlaneGeo.h.

Referenced by ClosestWireID(), Depth(), geo::WireReadoutDumper::dumpTPCplane(), GetNormalAxis(), HasWire(), LastWire(), MiddleWire(), NearestWireID(), NElements(), PrintPlaneInfo(), UpdateIncreasingWireDir(), and UpdateWirePitch().

231 { return fWire.size(); }

geo::PlaneGeo::fWire

WireCollection_t fWire

List of wires in this plane.

Definition: PlaneGeo.h:1209

Orient_t geo::PlaneGeo::Orientation ( ) const

inline

What is the orientation of the plane.

Definition at line 158 of file PlaneGeo.h.

References fOrientation, and ThetaZ().

Referenced by PrintPlaneInfo().

158 { return fOrientation; }

Orient_t fOrientation

Is the plane vertical or horizontal?

Definition: PlaneGeo.h:1208

std::string geo::PlaneGeo::OrientationName ( Orient_t orientation )

static

Returns the name of the specified orientation.

Definition at line 599 of file PlaneGeo.cxx.

References geo::kHorizontal, and geo::kVertical.

Referenced by PrintPlaneInfo(), and SetView().

   {
     switch (orientation) {
     case kHorizontal: return "horizontal"; break;
     case kVertical: return "vertical"; break;
     default: return "unexpected"; break;
     }
   }

double geo::PlaneGeo::PhiZ ( ) const

inline

Angle from positive z axis of the wire coordinate axis, in radians.

Definition at line 164 of file PlaneGeo.h.

References fCosPhiZ, and fSinPhiZ.

Referenced by PrintPlaneInfo(), and geo::WireReadoutGeom::ThirdPlane_dTdW().

164 { return std::atan2(fSinPhiZ, fCosPhiZ); }

geo::PlaneGeo::fSinPhiZ

double fSinPhiZ

Sine of .

Definition: PlaneGeo.h:1211

geo::PlaneGeo::fCosPhiZ

double fCosPhiZ

Cosine of .

Definition: PlaneGeo.h:1212

double geo::PlaneGeo::PlaneCoordinate ( Point_t const & point ) const

inline

Returns the coordinate of the point on the plane.

Parameters

point world coordinate of the point to get the coordinate of [cm]

Returns: the coordinate of the point [cm]

See also: PlaneCoordinateFrom(TVector3 const&, geo::Wire const&)

The method returns the coordinate of the point in the direction measured by the wires on this plane starting on the first wire, in world units (that is, centimeters). A point on the first wire will have coordinate 0.0, one on the next wire will have coordinate equal to a single wire pitch, etc.

The point does not need to be on the plane, and the projection of the point to the plane is considered.

Definition at line 684 of file PlaneGeo.h.

References fDecompWire, and geo::Decomposer< Vector, Point, ProjVector >::PointSecondaryComponent().

Referenced by WireCoordinate().

     {
       return fDecompWire.PointSecondaryComponent(point);
     }

double geo::PlaneGeo::PlaneCoordinateFrom	(	Point_t const &	point,
		WireGeo const &	refWire
	)		const

inline

Returns the coordinate of point on the plane respect to a wire.

Parameters

point	world coordinate of the point to get the coordinate of [cm]
refWire	reference wire

Returns: the coordinate of the point [cm]

See also: WireCoordinate()

The method returns the coordinate of the point in the direction measured by the wires on this plane starting from the specified reference wire, in world units (that is, centimeters).

The point does not need to be on the plane, and the projection of the point to the plane is considered. The reference wire, instead, must belong to this plane. This assumption is not checked, and if violated the results are undefined (in the current implementation, they are just wrong).

Definition at line 663 of file PlaneGeo.h.

References fDecompWire, geo::WireGeo::GetCenter(), and geo::Decomposer< Vector, Point, ProjVector >::VectorSecondaryComponent().

     {
       return fDecompWire.VectorSecondaryComponent(point - refWire.GetCenter());
     }

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

Returns a string with plane information.

See also: PrintPlaneInfo()

The information is provided by PrintPlaneInfo(), and the arguments have the same meaning.

Definition at line 422 of file PlaneGeo.cxx.

References PrintPlaneInfo().

Referenced by ActiveArea().

   {
     std::ostringstream sstr;
     PrintPlaneInfo(sstr, indent, verbosity);
     return sstr.str();
   }

WidthDepthProjection_t geo::PlaneGeo::PointWidthDepthProjection ( 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 wire plane. The vector is expressed as $ ( w, d ) $ , components following the width direction (WidthDir()) and the depth direction (DepthDir()) respectively. The origin point is the center of the plane.

Definition at line 897 of file PlaneGeo.h.

References fDecompFrame, and geo::Decomposer< Vector, Point, ProjVector >::ProjectPointOnPlane().

Referenced by isProjectionOnPlane(), MovePointOverPlane(), and larg4::LArVoxelReadout::RecoverOffPlaneDeposit().

     {
       return fDecompFrame.ProjectPointOnPlane(point);
     }

template<typename Stream >

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

Prints information about this plane.

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

Information on single wires is not printed. Note that the first line out the output is not indented.

Verbosity levels

0: only plane ID
1 _(default)_: also center and wire angle
2: also information about wires
3: also information about normal and increasing coordinate direction
4: also information about wire direction, width and depth
5: also coverage
6: also bounding box

Definition at line 1258 of file PlaneGeo.h.

References ActiveArea(), BoundingBox(), Depth(), lar::util::simple_geo::Rectangle< Data >::depth, DepthDir(), fDecompFrame, fDecompWire, GetCenter(), GetIncreasingWireDirection(), GetNormalDirection(), GetWireDirection(), ID(), lar::util::simple_geo::Range< Data >::lower, geo::Decomposer< Vector, Point, ProjVector >::NormalDir(), Nwires(), Orientation(), OrientationName(), PhiZ(), ThetaZ(), lar::util::simple_geo::Range< Data >::upper, View(), ViewName(), Width(), lar::util::simple_geo::Rectangle< Data >::width, WidthDir(), WireIDincreasesWithZ(), and WirePitch().

Referenced by ActiveArea(), geo::WireReadoutDumper::dumpTPCplane(), and PlaneInfo().

 {
 
   //----------------------------------------------------------------------------
   out << "plane " << std::string(ID());
 
   if (verbosity-- <= 0) return; // 0
 
   //----------------------------------------------------------------------------
   out << " at " << GetCenter() << " cm"
       << ", theta: " << ThetaZ() << " rad";
 
   if (verbosity-- <= 0) return; // 1
 
   //----------------------------------------------------------------------------
   unsigned int const nWires = Nwires();
 
   out << "\n"
       << indent << "normal to wire: " << PhiZ() << " rad"
       << ", with orientation " << OrientationName(Orientation()) << ", has " << nWires
       << " wires measuring " << ViewName(View()) << " with a wire pitch of " << WirePitch()
       << " cm";
 
   if (verbosity-- <= 0) return; // 2
 
   //----------------------------------------------------------------------------
   auto const& normal = GetNormalDirection();
   auto const& incrZdir = GetIncreasingWireDirection();
   auto const& wireNormalDir = fDecompWire.NormalDir();
   out << "\n"
       << indent << "normal to plane: " << normal
       << ", direction of increasing wire number: " << incrZdir
       << " [wire frame normal: " << wireNormalDir << "]"
       << " (" << (WireIDincreasesWithZ() ? "increases" : "decreases") << " with z)";
 
   if (verbosity-- <= 0) return; // 3
 
   //----------------------------------------------------------------------------
 
   auto const& wireDir = GetWireDirection();
   auto const& widthDir = WidthDir();
   auto const& depthDir = DepthDir();
   auto const& frameNormalDir = fDecompFrame.NormalDir();
 
   out << "\n"
       << indent << "wire direction: " << wireDir << "; width " << Width()
       << " cm in direction: " << widthDir << ", depth " << Depth()
       << " cm in direction: " << depthDir << " [normal: " << frameNormalDir << "]";
 
   if (verbosity-- <= 0) return; // 4
 
   //----------------------------------------------------------------------------
   // get the area spanned by the wires
   out << "\n"
       << indent << "wires cover width " << ActiveArea().width.lower << " to "
       << ActiveArea().width.upper << ", depth " << ActiveArea().depth.lower << " to "
       << ActiveArea().depth.upper << " cm";
   if (verbosity-- <= 0) return; // 5
 
   //----------------------------------------------------------------------------
   // print also the containing box
   auto const box = BoundingBox();
   out << "\n" << indent << "bounding box: " << box.Min() << " -- " << box.Max();
 }

WireCoordProjection_t geo::PlaneGeo::Projection ( 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 wire plane. The vector is expressed as $( \ell, w )$ . The component $\ell$ is measured on the direction of the first wire (see WireGeo::Direction()), using its center (see WireGeo::GetCenter()) as reference point. The component $ w $ is defined on the wire coordinate direction (see GetIncreasingWireDirection()), relative to the first wire, as it is returned by PlaneCoordinate().

The reference point is also returned by ProjectionReferencePoint().

Definition at line 755 of file PlaneGeo.h.

References fDecompWire, and geo::Decomposer< Vector, Point, ProjVector >::ProjectPointOnPlane().

Referenced by InterWireProjectedDistance(), and lar::util::TrackPitchInView().

     {
       return fDecompWire.ProjectPointOnPlane(point);
     }

WireCoordProjection_t geo::PlaneGeo::Projection ( 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

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 wire plane. The vector is expressed as $( \ell, w )$ . The component $\ell$ is measured on the direction of the first wire (see WireGeo::Direction()). The component $ w $ is defined on the wire coordinate direction (see GetIncreasingWireDirection()).

Definition at line 773 of file PlaneGeo.h.

References fDecompWire, and geo::Decomposer< Vector, Point, ProjVector >::ProjectVectorOnPlane().

     {
       return fDecompWire.ProjectVectorOnPlane(v);
     }

Point_t geo::PlaneGeo::ProjectionReferencePoint ( ) const

inline

Returns the reference point used by PointProjection().

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

Definition at line 736 of file PlaneGeo.h.

References fDecompWire, and geo::Decomposer< Vector, Point, ProjVector >::ReferencePoint().

736 { return fDecompWire.ReferencePoint(); }

geo::Decomposer::ReferencePoint

Point_t ReferencePoint() const

Returns the reference point for the plane coordinate, as a 3D point.

Definition: Decomposer.h:444

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1218

void geo::PlaneGeo::SetView ( View_t view )

inline

Set the signal view (for TPCGeo).

Definition at line 1128 of file PlaneGeo.h.

References fView, OrientationName(), SortWires(), UpdateAfterSorting(), and ViewName().

Referenced by UpdateView().

1128 { fView = view; }

geo::PlaneGeo::fView

View_t fView

Does this plane measure U, V, or W?

Definition: PlaneGeo.h:1207

bool geo::PlaneGeo::shouldFlipWire ( WireGeo const & wire ) const

private

Whether the specified wire should have start and end swapped.

Definition at line 953 of file PlaneGeo.cxx.

References geo::WireGeo::Direction(), GetIncreasingWireDirection(), and GetNormalDirection().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // The correct orientation is so that:
     //
     // (direction) x (wire coordinate direction) . (plane normal)
     //
     // is positive; it it's negative, then we should flip the wire.
     //
     // Note that the increasing wire direction comes from the wire frame, while the normal
     // direction is computed independently by geometry.  The resulting normal in the wire
     // frame is expected to be the same as the plane normal from GetNormalDirection(); if
     // this is not the case, flipping the wire direction should restore it.
 
     return wire.Direction().Cross(GetIncreasingWireDirection()).Dot(GetNormalDirection()) <
            +0.5; // should be in fact exactly +1
   }

double geo::PlaneGeo::SinPhiZ ( ) const

inline

Sine of PhiZ()

Definition at line 167 of file PlaneGeo.h.

References fSinPhiZ.

167 { return fSinPhiZ; }

geo::PlaneGeo::fSinPhiZ

double fSinPhiZ

Sine of .

Definition: PlaneGeo.h:1211

void geo::PlaneGeo::SortWires ( Compare< WireGeo > cmp )

Apply sorting to WireGeo objects.

Definition at line 410 of file PlaneGeo.cxx.

References fWire.

Referenced by SetView().

   {
     std::sort(fWire.begin(), fWire.end(), cmp);
   }

double geo::PlaneGeo::ThetaZ ( ) const

Angle of the wires from positive z axis; $\theta_{z} \in [ 0, \pi ]$ .

Definition at line 549 of file PlaneGeo.cxx.

References FirstWire(), and geo::WireGeo::ThetaZ().

Referenced by tca::dEdx(), Orientation(), and PrintPlaneInfo().

   {
     return FirstWire().ThetaZ();
   }

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

inline

Transform point from world frame to local plane frame.

Definition at line 1117 of file PlaneGeo.h.

References fTrans, and geo::LocalTransformationGeo< StoredMatrix, LocalPoint, LocalVector >::toLocalCoords().

1117 { return fTrans.toLocalCoords(world); }

geo::LocalTransformationGeo::toLocalCoords

LocalPoint_t toLocalCoords(GlobalPoint_t const &world) const

Transforms a point from world frame to local frame.

Definition: LocalTransformationGeo.h:126

geo::LocalTransformationGeo::toLocalCoords

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1206

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

inline

Transform direction vector from world to local.

Definition at line 1120 of file PlaneGeo.h.

References fTrans, and geo::LocalTransformationGeo< StoredMatrix, LocalPoint, LocalVector >::toLocalCoords().

1120 { return fTrans.toLocalCoords(world); }

LocalPoint_t toLocalCoords(GlobalPoint_t const &world) const

Transforms a point from world frame to local frame.

Definition: LocalTransformationGeo.h:126

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1206

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

inline

Transform point from local plane frame to world frame.

Definition at line 1111 of file PlaneGeo.h.

Referenced by BoundingBox(), ComposePoint(), DetectGeometryDirections(), util::GeometryUtilities::Get2DPointProjection(), GetBoxCenter(), and util::GeometryUtilities::GetProjectedPoint().

1111 { return fTrans.toWorldCoords(local); }

geo::LocalTransformationGeo::toWorldCoords

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1206

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:94

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

inline

Transform direction vector from local to world.

Definition at line 1114 of file PlaneGeo.h.

References fTrans, and geo::LocalTransformationGeo< StoredMatrix, LocalPoint, LocalVector >::toWorldCoords().

1114 { return fTrans.toWorldCoords(local); }

geo::LocalTransformationGeo::toWorldCoords

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1206

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:94

TGeoVolume const* geo::PlaneGeo::TPCVolume ( ) const

inline

Definition at line 149 of file PlaneGeo.h.

References fNode.

149 { return fNode->GetMotherVolume(); }

geo::PlaneGeo::fNode

TGeoNode const * fNode

Node within full geometry.

Definition: PlaneGeo.h:1205

void geo::PlaneGeo::UpdateActiveArea ( )

private

Updates the internally used active area.

Definition at line 916 of file PlaneGeo.cxx.

References fActiveArea.

Referenced by UpdateAfterSorting(), and Volume().

   {
     // The active area is defined in the width/depth space which include approximatively
     // all wires.
     //
     // See `ActiveAreaCalculator` for details of the algorithm.
 
     // we scratch 1 um from each side to avoid rounding errors later
     fActiveArea = ActiveAreaCalculator(*this, 0.0001);
   }

void geo::PlaneGeo::UpdateAfterSorting	(	PlaneID	planeid,
		BoxBoundedGeo const &	TPCbox
	)

Performs all needed updates after the TPC has sorted the planes.

Definition at line 555 of file PlaneGeo.cxx.

References fID, fWire, shouldFlipWire(), UpdateActiveArea(), UpdateDecompWireOrigin(), UpdateIncreasingWireDir(), UpdateOrientation(), UpdatePhiZ(), UpdatePlaneNormal(), UpdateView(), UpdateWidthDepthDir(), UpdateWireDir(), UpdateWirePitch(), and UpdateWirePlaneCenter().

Referenced by SetView().

   {
     // the order here matters
 
     // reset our ID
     fID = planeid;
 
     UpdatePlaneNormal(TPCbox);
     UpdateWidthDepthDir();
     UpdateIncreasingWireDir();
 
     // update wires
     WireID::WireID_t wireNo = 0;
     for (auto& wire : fWire) {
       wire.UpdateAfterSorting(WireID(fID, wireNo), shouldFlipWire(wire));
       ++wireNo;
     } // for wires
 
     UpdateDecompWireOrigin();
     UpdateWireDir();
     UpdateWirePlaneCenter();
     UpdateOrientation();
     UpdateWirePitch();
     UpdateActiveArea();
     UpdatePhiZ();
     UpdateView();
   }

void geo::PlaneGeo::UpdateDecompWireOrigin ( )

private

Updates the position of the wire coordinate decomposition.

Definition at line 909 of file PlaneGeo.cxx.

References fDecompWire, FirstWire(), GetCenter(), geo::Decomposer< Vector, Point, ProjVector >::SetOrigin(), and geo::vect::toPoint().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // update the origin of the reference frame (the middle of the first wire)
     fDecompWire.SetOrigin(vect::toPoint(FirstWire().GetCenter()));
   }

void geo::PlaneGeo::UpdateIncreasingWireDir ( )

private

Updates the cached direction to increasing wires.

Definition at line 856 of file PlaneGeo.cxx.

References e, fDecompWire, geo::WireGeo::GetCenter(), GetNormalDirection(), Nwires(), geo::vect::rounded01(), geo::Decomposer< Vector, Point, ProjVector >::SetSecondaryDir(), and Wire().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // Direction measured by the wires, pointing toward increasing wire number; requires:
     // - the normal to the plane to be correct
     // - wires to be sorted
 
     // 1) get the direction of the middle wire
     auto refWireNo = Nwires() / 2;
     if (refWireNo == Nwires() - 1) --refWireNo;
     auto const& refWire = Wire(refWireNo);
     auto const& WireDir = refWire.Direction(); // we only rely on the axis
 
     // 2) get the axis perpendicular to it on the wire plane (arbitrary direction)
     auto wireCoordDir = GetNormalDirection().Cross(WireDir).Unit();
 
     // 3) where is the next wire?
     auto toNextWire = Wire(refWireNo + 1).GetCenter() - refWire.GetCenter();
 
     // 4) if wireCoordDir is pointing away from the next wire, flip it
     if (wireCoordDir.Dot(toNextWire) < 0) { wireCoordDir = -wireCoordDir; }
     fDecompWire.SetSecondaryDir(vect::rounded01(wireCoordDir, 1e-4));
   }

void geo::PlaneGeo::UpdateOrientation ( )

private

Updates plane orientation.

Definition at line 694 of file PlaneGeo.cxx.

References util::abs(), e, fOrientation, fWire, GetNormalDirection(), geo::kHorizontal, and geo::kVertical.

Referenced by UpdateAfterSorting(), and Volume().

   {
     // this algorithm needs to know about the axis; the normal is expected to be already
     // updated.
 
     // sanity check
     if (fWire.size() < 2) {
       // this likely means construction is not complete yet
       throw cet::exception("NoWireInPlane")
         << "PlaneGeo::UpdateOrientation(): only " << fWire.size() << " wires!\n";
     } // if
 
     auto normal = GetNormalDirection();
 
     if (std::abs(std::abs(normal.X()) - 1.) < 1e-3)
       fOrientation = kVertical;
     else if (std::abs(std::abs(normal.Y()) - 1.) < 1e-3)
       fOrientation = kHorizontal;
     else {
       // at this point, the only problem is the lack of a label for this orientation;
       // probably introducing a geo::kOtherOrientation would suffice
       throw cet::exception("Geometry")
         << "Plane with unsupported orientation (normal: " << normal << ")\n";
     }
   }

void geo::PlaneGeo::UpdatePhiZ ( )

private

Updates the stored $\phi_{z}$ .

Definition at line 733 of file PlaneGeo.cxx.

References fCosPhiZ, fSinPhiZ, and GetIncreasingWireDirection().

Referenced by UpdateAfterSorting(), and Volume().

   {
     auto const& wire_coord_dir = GetIncreasingWireDirection();
     fCosPhiZ = wire_coord_dir.Z();
     fSinPhiZ = wire_coord_dir.Y();
   }

void geo::PlaneGeo::UpdatePlaneNormal ( BoxBoundedGeo const & TPCbox )

private

Updates the cached normal to plane versor; needs the TPC box coordinates.

Definition at line 826 of file PlaneGeo.cxx.

References geo::BoxBoundedGeo::Center(), e, fNormal, GetBoxCenter(), GetNormalAxis(), and geo::vect::round01().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // direction normal to the wire plane, points toward the center of TPC
 
     // start from the axis
     fNormal = GetNormalAxis();
 
     // now evaluate where we are pointing
     auto const towardCenter = TPCbox.Center() - GetBoxCenter();
 
     // if they are pointing in opposite directions, flip the normal
     if (fNormal.Dot(towardCenter) < 0) fNormal = -fNormal;
     vect::round01(fNormal, 1e-3);
   }

void geo::PlaneGeo::UpdateView ( )

private

Updates the stored view.

This algorithm assigns views according to the angle the wire axis cuts with y axis ("thetaY"), but from the point of view of the center of the TPC. A special case is when the drift axis is on y axis.

In the normal case, the discrimination happens on the the arctangent of the point { (y,w), (y x n,w) }, where w is the wire direction, y is the coordinate axis and n the normal to the wire plane. This definition gives the same value regardless of the direction of w on its axis.

If thetaY is 0, wires are parallel to the y axis, the view is assigned as kX or kZ depending on whether the plane normal is closer to the z axis or the x axis, respectively (the normal describes a direction not measured by the wires).

If thetaY is a right angle, the wires are orthogonal to y axis and view kY view is assigned. If thetaY is smaller than 0, the view is called "U". If thetaY is larger than 0, the view is called "V".

The special case where the drift axis is on y axis is treated separately. In that case, the role of y axis is replaced by the z axis and the discriminating figure is equivalent to the usual ThetaZ().

If thetaZ is 0, the wires are measuring x and kX view is chosen. If thetaZ is a right angle, the wires are measuring z and kZ view is chosen. If thetaZ is smaller than 0, the view is called "U". If thetaZ is larger than 0, the view is called "V".

Definition at line 740 of file PlaneGeo.cxx.

References util::abs(), geo::vect::dot(), e, GetNormalDirection(), GetWireDirection(), geo::kU, geo::kV, geo::kX, geo::kY, geo::kZ, geo::vect::mixedProduct(), SetView(), geo::Xaxis(), geo::Yaxis(), and geo::Zaxis().

Referenced by UpdateAfterSorting(), and Volume().

   {
     auto const& normalDir = GetNormalDirection();
     auto const& wireDir = GetWireDirection();
 
     // normal direction has been rounded, so exact comparison can work
     if (std::abs(normalDir.Y()) != 1.0) {
       // normal case: drift direction is not along y (vertical)
 
       // yw is pretty much GetWireDirection().Y()...  thetaY is related to atan2(ynw, yw)
       double const yw = vect::dot(wireDir, Yaxis());
       double const ynw = vect::mixedProduct(Yaxis(), normalDir, wireDir);
 
       if (std::abs(yw) < 1.0e-4) { // wires orthogonal to y axis
         double const closeToX = std::abs(vect::dot(normalDir, Xaxis()));
         double const closeToZ = std::abs(vect::dot(normalDir, Zaxis()));
         SetView((closeToZ > closeToX) ? kX : kY);
       }
       else if (std::abs(ynw) < 1.0e-4) { // wires parallel to y axis
         SetView(kZ);
       }
       else if ((ynw * yw) < 0)
         SetView(kU); // different sign => thetaY > 0
       else if ((ynw * yw) > 0)
         SetView(kV); // same sign => thetaY < 0
       else
         assert(false); // logic error?!
     }
     else { // if drift is vertical
       // special case: drift direction is along y (vertical)
 
       // zw is pretty much GetWireDirection().Z()...
       double const zw = vect::dot(wireDir, Zaxis());
       // while GetNormalDirection() axis is on y, its direction is not fixed:
       double const znw = vect::mixedProduct(Zaxis(), normalDir, wireDir);
 
       // thetaZ is std::atan(znw/zw)
 
       if (std::abs(zw) < 1.0e-4) { // orthogonal to z, orthogonal to y...
         // this is equivalent to thetaZ = +/- pi/2
         SetView(kZ);
       }
       else if (std::abs(znw) < 1.0e-4) { // parallel to z, orthogonal to y...
         // this is equivalent to thetaZ = 0
         SetView(kX);
       }
       else if ((znw * zw) < 0)
         SetView(kU); // different sign => thetaZ > 0
       else if ((znw * zw) > 0)
         SetView(kV); // same sign => thetaZ < 0
       else
         assert(false); // logic error?!
 
     } // if drift direction... else
   }

void geo::PlaneGeo::UpdateWidthDepthDir ( )

private

Updates the cached depth and width direction.

Definition at line 842 of file PlaneGeo.cxx.

References DepthDir(), e, fDecompFrame, GetNormalDirection(), geo::vect::rounded01(), geo::Decomposer< Vector, Point, ProjVector >::SecondaryDir(), geo::Decomposer< Vector, Point, ProjVector >::SetSecondaryDir(), and WidthDir().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // fix the positiveness of the width/depth/normal frame
 
     // The basis is already set and orthonormal, with only the width and depth directions
     // arbitrary.  We choose the direction of the secondary axis ("depth") so that the
     // frame normal is oriented in the general direction of the plane normal (the latter
     // is computed independently).
     if (WidthDir().Cross(DepthDir()).Dot(GetNormalDirection()) < 0.0) {
       fDecompFrame.SetSecondaryDir(vect::rounded01(-fDecompFrame.SecondaryDir(), 1e-4));
     }
   }

void geo::PlaneGeo::UpdateWireDir ( )

private

Updates the cached direction to wire.

Definition at line 880 of file PlaneGeo.cxx.

References e, fDecompWire, FirstWire(), GetNormalDirection(), lar::util::makeVector3DComparison(), geo::Decomposer< Vector, Point, ProjVector >::NormalDir(), geo::vect::rounded01(), and geo::Decomposer< Vector, Point, ProjVector >::SetMainDir().

Referenced by UpdateAfterSorting(), and Volume().

   {
     fDecompWire.SetMainDir(vect::rounded01(FirstWire().Direction(), 1e-4));
 
     // check that the resulting normal matches the plane one
     assert(
       lar::util::makeVector3DComparison(1e-5).equal(fDecompWire.NormalDir(), GetNormalDirection()));
   }

void geo::PlaneGeo::UpdateWirePitch ( )

private

Updates the stored wire pitch.

Definition at line 721 of file PlaneGeo.cxx.

References fWirePitch, Nwires(), Wire(), and geo::WireGeo::WirePitch().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // pick long wires around the center of the detector, so that their coordinates are
     // defined with better precision
     assert(Nwires() > 1);
 
     auto const iWire = Nwires() / 2;
 
     fWirePitch = WireGeo::WirePitch(Wire(iWire - 1), Wire(iWire));
   }

void geo::PlaneGeo::UpdateWirePitchSlow ( )

private

Updates the stored wire pitch with a slower, more robust algorithm.

Definition at line 890 of file PlaneGeo.cxx.

References e, fWire, fWirePitch, and geo::WireGeo::WirePitch().

Referenced by PlaneGeo(), and Volume().

   {
     if (fWire.empty()) { return; }
 
     // Compare one wire (the first one, for convenience) with all other wires; the wire
     // pitch is the smallest distance we find.
     //
     // This algorithm assumes wire pitch is constant, but it does not assume wire ordering
     auto firstWire = fWire.cbegin(), wire = firstWire, wend = fWire.cend();
     fWirePitch = WireGeo::WirePitch(*firstWire, *(++wire));
 
     while (++wire != wend) {
       auto wirePitch = WireGeo::WirePitch(*firstWire, *wire);
       if (wirePitch < 1e-4) continue; // it's 0!
       if (wirePitch < fWirePitch) fWirePitch = wirePitch;
     }
   }

void geo::PlaneGeo::UpdateWirePlaneCenter ( )

private

Updates the stored wire plane center.

Definition at line 928 of file PlaneGeo.cxx.

References DistanceFromPlane(), DriftPoint(), e, fCenter, fDecompFrame, GetBoxCenter(), geo::vect::round0(), and geo::Decomposer< Vector, Point, ProjVector >::SetOrigin().

Referenced by UpdateAfterSorting(), and Volume().

   {
     // The center of the wire plane is defined as the center of the plane box, translated
     // to the plane the wires lie on.  This assumes that the thickness direction of the
     // box is aligned with the drift direction, so that the translated point is still in
     // the middle of width and depth dimensions.  It is possible to remove that assumption
     // by translating the center of the box along the thickness direction enough to bring
     // it to the wire plane.  The math is just a bit less straightforward, so we don't
     // bother yet.
     //
     // Requirements:
     //  * the wire decomposition frame must be set up (at least its origin and normal
     //    direction)
 
     fCenter = GetBoxCenter();
 
     DriftPoint(fCenter, DistanceFromPlane(fCenter));
 
     vect::round0(fCenter, 1e-7); // round dimensions less than 1 nm to 0
 
     fDecompFrame.SetOrigin(fCenter); // equivalent to GetCenter() now
 
   } // PlaneGeo::UpdateWirePlaneCenter()

WidthDepthProjection_t geo::PlaneGeo::VectorWidthDepthProjection ( 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

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 wire plane. The vector is expressed as $ ( w, d ) $ , components following the width direction (WidthDir()) and the depth direction (DepthDir()) respectively.

Definition at line 914 of file PlaneGeo.h.

References DeltaFromPlane(), fDecompFrame, isProjectionOnPlane(), proj, and geo::Decomposer< Vector, Point, ProjVector >::ProjectVectorOnPlane().

     {
       return fDecompFrame.ProjectVectorOnPlane(v);
     }

View_t geo::PlaneGeo::View ( ) const

inline

Which coordinate does this plane measure.

Definition at line 155 of file PlaneGeo.h.

References fView.

Referenced by ShowerRecoTools::ShowerUnidirectiondEdx::CalculateElement(), util::GeometryUtilities::Get2DangleFrom3D(), corner::CornerFinderAlg::get_feature_points(), corner::CornerFinderAlg::get_feature_points_LineIntegralScore(), shower::EMShowerAlg::MakeShower(), geo::WireReadoutGeom::Plane(), PrintPlaneInfo(), cluster::TrajCluster::produce(), cluster::SmallClusterFinder::produce(), lar_pandora::DUNEFarDetVDThreeView::TargetViewU(), lar_pandora::ICARUS::TargetViewU(), lar_pandora::VintageLArTPCThreeView::TargetViewU(), lar_pandora::DUNEFarDetVDThreeView::TargetViewV(), lar_pandora::ICARUS::TargetViewV(), lar_pandora::VintageLArTPCThreeView::TargetViewV(), lar_pandora::DUNEFarDetVDThreeView::TargetViewW(), lar_pandora::ICARUS::TargetViewW(), and geo::WireReadoutGeom::View().

155 { return fView; }

geo::PlaneGeo::fView

View_t fView

Does this plane measure U, V, or W?

Definition: PlaneGeo.h:1207

std::string geo::PlaneGeo::ViewName ( View_t view )

static

Returns the name of the specified view.

Definition at line 584 of file PlaneGeo.cxx.

References geo::k3D, geo::kU, geo::kUnknown, geo::kV, geo::kX, geo::kY, geo::kZ, and util::to_string().

Referenced by nnet::WaveformDenoiseTest::analyze(), nnet::NoiseWaveformDump::analyze(), nnet::RawWaveformDump::analyze(), nnet::RawWaveformClnSigDump::analyze(), trkf::SeedFinderAlgorithm::GetCenterAndDirection(), PrintPlaneInfo(), SetView(), lar::util::TrackPitchInView(), and geo::WireReadoutGeom::WireAngleToVertical().

   {
     switch (view) {
     case kU: return "U";
     case kV: return "V";
     case kZ: return "Z";
     case kY: return "Y";
     case kX: return "X";
     case k3D: return "3D";
     case kUnknown: return "?";
     default: return "<UNSUPPORTED (" + std::to_string((int)view) + ")>";
     }
   }

TGeoVolume const& geo::PlaneGeo::Volume ( ) const

inlineprivate

Definition at line 1145 of file PlaneGeo.h.

References DetectGeometryDirections(), fNode, GetNormalAxis(), shouldFlipWire(), UpdateActiveArea(), UpdateDecompWireOrigin(), UpdateIncreasingWireDir(), UpdateOrientation(), UpdatePhiZ(), UpdatePlaneNormal(), UpdateView(), UpdateWidthDepthDir(), UpdateWireDir(), UpdateWirePitch(), UpdateWirePitchSlow(), and UpdateWirePlaneCenter().

Referenced by BoundingBox(), and DetectGeometryDirections().

1145 { return *fNode->GetVolume(); }

geo::PlaneGeo::fNode

TGeoNode const * fNode

Node within full geometry.

Definition: PlaneGeo.h:1205

double geo::PlaneGeo::Width ( ) const

inline

Return the width of the plane.

See also: Depth(), WidthDir(), DepthDir()

The precise definition is arbitrary (see WidthDir()).

Definition at line 210 of file PlaneGeo.h.

References fFrameSize, and geo::PlaneGeo::RectSpecs::Width().

Referenced by PrintPlaneInfo().

210 { return fFrameSize.Width(); }

geo::PlaneGeo::fFrameSize

RectSpecs fFrameSize

Definition: PlaneGeo.h:1223

geo::PlaneGeo::RectSpecs::Width

double Width() const

Definition: PlaneGeo.h:1201

Vector_t const& geo::PlaneGeo::WidthDir ( ) const

inline

Return the direction of plane width.

The precise definition of the sides is arbitrary, but they are defined to lie on the wire plane and so that WidthDir(), DepthDir() and GetNormalDirection() make a orthonormal base. That base (width, depth, normal) is guaranteed to be positive defined.

Definition at line 189 of file PlaneGeo.h.

References fDecompFrame, and geo::Decomposer< Vector, Point, ProjVector >::MainDir().

Referenced by MovePointOverPlane(), PrintPlaneInfo(), and UpdateWidthDepthDir().

189 { return fDecompFrame.MainDir(); }

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1222

geo::Decomposer::MainDir

Vector_t const & MainDir() const

Returns the plane main axis direction.

Definition: Decomposer.h:450

WireGeo const & geo::PlaneGeo::Wire ( unsigned int iwire ) const

Return the iwire'th wire in the plane.

Exceptions

cet::exception (category "WireOutOfRange") if no such wire

Note: In the past, no check was performed.

Definition at line 403 of file PlaneGeo.cxx.

References WirePtr().

Referenced by geo::WireReadoutDumper::dumpTPCplane(), FirstWire(), GetElement(), GetNormalAxis(), HasElement(), LastWire(), MiddleWire(), NearestWire(), UpdateIncreasingWireDir(), UpdateWirePitch(), and geo::WireReadoutGeom::Wire().

   {
     if (WireGeo const* pWire = WirePtr(iwire)) { return *pWire; }
     throw cet::exception("WireOutOfRange") << "Request for non-existant wire " << iwire << "\n";
   }

WireGeo const& geo::PlaneGeo::Wire ( WireID const & wireid ) const

inline

Returns the wire in wireid from this plane.

Parameters

wireid full wire ID

Returns: a constant reference to the wire in wireid

Exceptions

cet::exception (category "WireOutOfRange") if no such wire

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

Definition at line 273 of file PlaneGeo.h.

References Wire(), and geo::WireID::Wire.

Referenced by Wire().

273 { return Wire(wireid.Wire); }

Referenced by tca::ChgFracBetween(), tca::ChgFracNearEnd(), cluster::MergeClusterAlg::GlobalWire(), lar_cluster3d::PCASeedFinderAlg::LineFit2DHits(), lar_cluster3d::HoughSeedFinderAlg::LineFit2DHits(), tca::MakeBareTP(), tca::MakeTP3D(), lar_cluster3d::StandardHit3DBuilder::NearestWireID(), lar_cluster3d::SnippetHit3DBuilder::NearestWireID(), NearestWireID(), shower::EMShowerAlg::OrderShowerHits_(), trkf::CCTrackMaker::PlnMatch(), tca::PosInPlane(), tca::SetSection(), trkf::TrackLineFitAlg::TrkLineFit(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:403

double geo::PlaneGeo::WireCoordinate ( Point_t const & point ) const

inline

Returns the coordinate of the point on the plane, in wire units.

Parameters

point world coordinate of the point to get the coordinate of

Returns: the coordinate of the point, in wire pitch units

See also: CoordinateFrom(TVector3 const&, geo::Wire const&)

The method returns the coordinate of the point in the direction measured by the wires on this plane starting on the first wire, in wire units (that is, wire pitches). A point on the first wire will have coordinate 0.0, one on the next wire will have coordinate 1.0, etc.

The point does not need to be on the plane, and the projection of the point to the plane is considered.

Definition at line 704 of file PlaneGeo.h.

References PlaneCoordinate(), and WirePitch().

     {
       return PlaneCoordinate(point) / WirePitch();
     }

bool geo::PlaneGeo::WireIDincreasesWithZ ( ) const

Returns whether the higher z wires have higher wire ID.

Returns: whether the higher z wires have higher wire ID

See also: GetIncreasingWireDirection()

This method is related to GetIncreasingWireDirection() (it might be expressed as "GetIncreasingWireDirection()[2] > 0"), but it is implemented in a faster and independent way.

Definition at line 416 of file PlaneGeo.cxx.

References e, GetIncreasingWireDirection(), lar::util::RealComparisons< RealType >::nonNegative(), and geo::Z.

Referenced by PrintPlaneInfo(), and WirePitch().

   {
     return lar::util::RealComparisons(1e-3).nonNegative(GetIncreasingWireDirection().Z());
   }

double geo::PlaneGeo::WirePitch ( ) const

inline

Return the wire pitch (in centimeters). It is assumed constant.

Definition at line 312 of file PlaneGeo.h.

References fWirePitch, and WireIDincreasesWithZ().

Referenced by apa::APAGeometryAlg::APAGeometryAlg(), tca::dEdx(), lar_cluster3d::HoughSeedFinderAlg::findHoughClusters(), pma::ProjectionMatchingAlg::GetCloseHits_(), shower::LArPandoraShowerAlg::HitCoordinates(), shower::EMShowerAlg::HitPosition_(), lar_cluster3d::PCASeedFinderAlg::LineFit2DHits(), lar_cluster3d::HoughSeedFinderAlg::LineFit2DHits(), shower::EMShowerAlg::MakeShower(), shower::LArPandoraShowerAlg::OrderShowerHits(), util::GeometryUtilities::PitchInView(), PrintPlaneInfo(), geo::WireReadoutGeom::ThirdPlane_dTdW(), lar::util::TrackPitchInView(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc_test(), trkf::VertexFitAlg::VertexFit(), and WireCoordinate().

312 { return fWirePitch; }

geo::PlaneGeo::fWirePitch

double fWirePitch

Pitch of wires in this plane.

Definition: PlaneGeo.h:1210

auto geo::PlaneGeo::WirePtr ( unsigned int iwire ) const

inline

Returns the wire number iwire from this plane.

Parameters

iwire the number of local wire

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

Definition at line 282 of file PlaneGeo.h.

References fWire, and HasWire().

Referenced by GetElementPtr(), Wire(), and geo::WireReadoutGeom::WirePtr().

282 { return HasWire(iwire) ? &fWire[iwire] : nullptr; }

geo::PlaneGeo::fWire

WireCollection_t fWire

List of wires in this plane.

Definition: PlaneGeo.h:1209