Geometry information for a single wire plane.The plane is represented in the geometry by a solid which contains wires. Currently, only box solids are well supported. The box which is representation of the plane has some thickness, and it should not be assumed that the wires are in the median section of it, that is, the center of the box may not lie on the plane defined by the wires. More...

#include "PlaneGeo.h"

Classes
struct	PlaneGeoCoordinatesTag
	Tag for vectors in the "local" GDML coordinate frame of the plane. More...

struct	RectSpecs

struct	WidthDepthReferenceTag
	Tag for plane frame base vectors. More...

struct	WireCoordinateReferenceTag
	Tag for wire base vectors. More...

Public Types
using	GeoNodePath_t = std::vector< TGeoNode const * >

using	Rect = lar::util::simple_geo::Rectangle< double >
	Type for description of rectangles. More...

Types for geometry-local reference vectors.
These types represents points and displacement vectors in the reference frame defined in the plane geometry box from the GDML geometry description. No alias is explicitly defined for the LArSoft global vector types, `geo::Point_t` and `geo::Vector_t`. Remember the `LocalPoint_t` and `LocalVector_t` vectors from different instances of `geo::PlaneGeo` have the same type but are not compatible.
using	LocalPoint_t = geo::Point3DBase_t< PlaneGeoCoordinatesTag >
	Type of points in the local GDML wire plane frame. More...

using	LocalVector_t = geo::Vector3DBase_t< PlaneGeoCoordinatesTag >
	Type of displacement vectors in the local GDML wire plane frame. More...

Types for vectors in the wire coordinate frame.
using	WireCoordProjection_t = ROOT::Math::DisplacementVector2D< ROOT::Math::Cartesian2D< double >, WireCoordinateReferenceTag >
	Type for projections in the wire base representation. More...

using	WireDecomposer_t = geo::Decomposer< geo::Vector_t, geo::Point_t, WireCoordProjection_t >
	Type used for plane decompositions on wire base. More...

using	WireDecomposedVector_t = WireDecomposer_t::DecomposedVector_t
	Type describing a 3D point or vector decomposed on a plane on wire base. More...

Types for vectors in the width/depth coordinate frame.
using	WidthDepthProjection_t = ROOT::Math::DisplacementVector2D< ROOT::Math::Cartesian2D< double >, WidthDepthReferenceTag >

using	WidthDepthDisplacement_t = ROOT::Math::DisplacementVector2D< ROOT::Math::Cartesian2D< double >, WidthDepthReferenceTag >
	Type for vector projections in the plane frame base representation. More...

using	WidthDepthDecomposer_t = geo::Decomposer< geo::Vector_t, geo::Point_t, WidthDepthProjection_t >
	Type used for plane decompositions on plane frame (width/depth). More...

using	WDDecomposedVector_t = WidthDepthDecomposer_t::DecomposedVector_t

Public Member Functions
	PlaneGeo (GeoNodePath_t &path, size_t depth)
	Construct a representation of a single plane of the detector. More...

WireGeo const &	Wire (unsigned int iwire) const

WireGeo const *	WirePtr (unsigned int iwire) const
	Returns the wire number iwire from this plane. More...

const WireGeo &	FirstWire () const
	Return the first wire in the plane. More...

const WireGeo &	MiddleWire () const
	Return the middle wire in the plane. More...

const WireGeo &	LastWire () const
	Return the last wire in the plane. More...

auto	IterateWires () const
	Allows range-for iteration on all wires in this plane. More...

geo::WireGeo const &	NearestWire (geo::Point_t const &pos) const
	Returns the wire closest to the specified position. More...

geo::WireID	ClosestWireID (geo::WireID::WireID_t wireNo) const
	Returns the closest valid wire ID to the specified wire. More...

geo::WireID	ClosestWireID (geo::WireID const &wireid) const
	Returns the closest valid wire ID to the specified wire. More...

Rect const &	ActiveArea () const
	Returns an area covered by the wires in the plane. More...

lar::util::simple_geo::Volume	Coverage () const
	Returns a volume including all the wires in the plane. More...

template<typename Stream >
void	PrintPlaneInfo (Stream &&out, std::string indent="", unsigned int verbosity=1) const
	Prints information about this plane. More...

template<typename Point = DefaultPoint_t>
double	WireCoordinate (Point const &point) const
	Returns the coordinate of the point on the plane, in wire units. More...

template<typename Point = DefaultPoint_t>
Point	ProjectionReferencePoint () const
	Returns the reference point used by `PointProjection()`. More...

template<typename Point = DefaultPoint_t>
Point	ComposePoint (WireDecomposedVector_t const &decomp) const
	Returns the 3D vector from composition of projection and distance. More...

template<typename Point = DefaultPoint_t>
Point	ComposePoint (double distance, WireCoordProjection_t const &proj) const
	Returns the 3D point from composition of projection and distance. More...

WidthDepthProjection_t	DeltaFromPlane (WidthDepthProjection_t const &proj, double wMargin, double dMargin) const
	Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the plane. More...

WidthDepthProjection_t	DeltaFromPlane (WidthDepthProjection_t const &proj, double margin=0.0) const
	Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the area of plane. More...

WidthDepthProjection_t	DeltaFromActivePlane (WidthDepthProjection_t const &proj, double wMargin, double dMargin) const
	Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the active area of plane. More...

WidthDepthProjection_t	DeltaFromActivePlane (WidthDepthProjection_t const &proj, double margin=0.0) const
	Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the active area of plane. More...

WidthDepthProjection_t	MoveProjectionToPlane (WidthDepthProjection_t const &proj) const
	Returns the projection, moved onto the plane if necessary. More...

template<typename Point = DefaultPoint_t>
Point	ComposePoint (WDDecomposedVector_t const &decomp) const
	Returns the 3D vector from composition of projection and distance. More...

template<typename Point = DefaultPoint_t>
Point	ComposePoint (double distance, WidthDepthProjection_t const &proj) const
	Returns the 3D point from composition of projection and distance. More...

void	SortWires (geo::GeoObjectSorter const &sorter)
	Apply sorting to WireGeo objects. More...

void	UpdateAfterSorting (geo::PlaneID planeid, geo::BoxBoundedGeo const &TPCbox)
	Performs all needed updates after the TPC has sorted the planes. More...

Plane properties
View_t	View () const
	Which coordinate does this plane measure. More...

Orient_t	Orientation () const
	What is the orientation of the plane. More...

double	ThetaZ () const
	Angle of the wires from positive z axis; $\theta_{z} \in [ 0, \pi ]$ . More...

double	PhiZ () const
	Angle from positive z axis of the wire coordinate axis, in radians. More...

double	SinPhiZ () const
	Sine of PhiZ() More...

double	CosPhiZ () const
	Cosine of PhiZ() More...

geo::PlaneID const &	ID () const
	Returns the identifier of this plane. More...

Plane size and coordinates
template<typename Vector = DefaultVector_t>
Vector	WidthDir () const
	Return the direction of plane width. More...

template<typename Vector = DefaultVector_t>
Vector	DepthDir () const
	Return the direction of plane depth. More...

double	Width () const
	Return the width of the plane. More...

double	Depth () const
	Return the depth of the plane. More...

geo::BoxBoundedGeo	BoundingBox () const

Wire access
unsigned int	Nwires () const
	Number of wires in this plane. More...

unsigned int	NElements () const
	Number of wires in this plane. More...


bool	HasWire (unsigned int iwire) const
	Returns whether a wire with index iwire is present in this plane. More...

bool	HasElement (unsigned int iwire) const
	Returns whether a wire with index iwire is present in this plane. More...


bool	HasWire (geo::WireID const &wireid) const
	Returns whether the wire in wireid is present in this plane. More...

bool	HasElement (geo::WireID const &wireid) const
	Returns whether the wire in wireid is present in this plane. More...


WireGeo const &	Wire (WireID const &wireid) const
	Returns the wire in wireid from this plane. More...

WireGeo const &	GetElement (WireID const &wireid) const
	Returns the wire in wireid from this plane. More...


WireGeo const *	WirePtr (WireID const &wireid) const
	Returns the wire in wireid from this plane. More...

WireGeo const *	GetElementPtr (WireID const &wireid) const
	Returns the wire in wireid from this plane. More...

Plane geometry properties
double	WirePitch () const
	Return the wire pitch (in centimeters). It is assumed constant. More...

bool	WireIDincreasesWithZ () const
	Returns whether the higher z wires have higher wire ID. More...

template<typename Vector = DefaultVector_t>
Vector	GetNormalDirection () const
	Returns the direction normal to the plane. More...

template<typename Vector = DefaultVector_t>
Vector	GetIncreasingWireDirection () const
	Returns the direction of increasing wires. More...

template<typename Point = DefaultPoint_t>
Point	GetCenter () const
	Returns the centre of the wire plane in world coordinates [cm]. More...

template<typename Point = DefaultPoint_t>
Point	GetBoxCenter () const
	Returns the centre of the box representing the plane. More...

template<typename Vector = DefaultVector_t>
Vector	GetWireDirection () const
	Returns the direction of the wires. More...

geo::WireID	NearestWireID (geo::Point_t const &pos) const
	Returns the ID of wire closest to the specified position. More...

geo::WireID	NearestWireID (TVector3 const &pos) const
	Return the wire pitch (in centimeters). It is assumed constant. More...


double	DistanceFromPlane (geo::Point_t const &point) const
	Returns the distance of the specified point from the wire plane. More...

double	DistanceFromPlane (TVector3 const &point) const
	Returns the distance of the specified point from the wire plane. More...


void	DriftPoint (geo::Point_t &position, double distance) const
	Shifts the position of an electron drifted by a distance. More...

void	DriftPoint (TVector3 &position, double distance) const
	Shifts the position of an electron drifted by a distance. More...


void	DriftPoint (geo::Point_t &position) const
	Shifts the position along drift direction to fall on the plane. More...

void	DriftPoint (TVector3 &position) const
	Shifts the position along drift direction to fall on the plane. More...

Projections on wire length/wire coordinate direction base
These methods deal with projection of points and vectors on the plane, using a geometric reference base which is dependent on the wire direction. This is useful for plane reconstruction.
double	PlaneCoordinateFrom (geo::Point_t const &point, geo::WireGeo const &refWire) const
	Returns the coordinate of point on the plane respect to a wire. More...

double	PlaneCoordinateFrom (TVector3 const &point, geo::WireGeo const &refWire) const
	Returns the coordinate of point on the plane respect to a wire. More...


double	PlaneCoordinate (geo::Point_t const &point) const
	Returns the coordinate of the point on the plane. More...

double	PlaneCoordinate (TVector3 const &point) const
	Returns the coordinate of the point on the plane. More...


WireDecomposedVector_t	DecomposePoint (geo::Point_t const &point) const
	Decomposes a 3D point in two components. More...

WireDecomposedVector_t	DecomposePoint (TVector3 const &point) const
	Decomposes a 3D point in two components. More...


WireCoordProjection_t	Projection (geo::Point_t const &point) const
	Returns the projection of the specified point on the plane. More...

WireCoordProjection_t	PointProjection (geo::Point_t const &point) const
	Returns the projection of the specified point on the plane. More...

WireCoordProjection_t	PointProjection (TVector3 const &point) const
	Returns the projection of the specified point on the plane. More...


WireCoordProjection_t	Projection (geo::Vector_t const &v) const
	Returns the projection of the specified vector on the plane. More...

WireCoordProjection_t	VectorProjection (geo::Vector_t const &v) const
	Returns the projection of the specified vector on the plane. More...

WireCoordProjection_t	VectorProjection (TVector3 const &v) const
	Returns the projection of the specified vector on the plane. More...

Projection on width/depth plane
These methods deal with projection of points and vectors on the plane, using a geometric reference base which is not dependent on the wire direction. This is more useful when comparing with the TPC or other planes.
WDDecomposedVector_t	DecomposePointWidthDepth (geo::Point_t const &point) const
	Decomposes a 3D point in two components. More...

WDDecomposedVector_t	DecomposePointWidthDepth (TVector3 const &point) const
	Decomposes a 3D point in two components. More...


WidthDepthProjection_t	PointWidthDepthProjection (geo::Point_t const &point) const
	Returns the projection of the specified point on the plane. More...

WidthDepthProjection_t	PointWidthDepthProjection (TVector3 const &point) const
	Returns the projection of the specified point on the plane. More...


WidthDepthProjection_t	VectorWidthDepthProjection (geo::Vector_t const &v) const
	Returns the projection of the specified vector on the plane. More...

WidthDepthProjection_t	VectorWidthDepthProjection (TVector3 const &v) const
	Returns the projection of the specified vector on the plane. More...


bool	isProjectionOnPlane (geo::Point_t const &point) const
	Returns if the projection of specified point is within the plane. More...

bool	isProjectionOnPlane (TVector3 const &point) const
	Returns if the projection of specified point is within the plane. More...


geo::Point_t	MovePointOverPlane (geo::Point_t const &point) const
	Returns the point, moved so that its projection is over the plane. More...

TVector3	MovePointOverPlane (TVector3 const &point) const
	Returns the point, moved so that its projection is over the plane. More...

Coordinate transformation
Local points and displacement vectors are described by the types `geo::PlaneGeo::LocalPoint_t` and `geo::PlaneGeo::LocalVector_t`, respectively.
void	LocalToWorld (const double plane, double world) const
	Transform point from local plane frame to world frame. More...

TVector3	LocalToWorld (const TVector3 &local) const
	Transform point from local plane frame to world frame. More...

geo::Point_t	toWorldCoords (LocalPoint_t const &local) const
	Transform point from local plane frame to world frame. More...

void	LocalToWorldVect (const double plane, double world) const
	Transform direction vector from local to world. More...

TVector3	LocalToWorldVect (const TVector3 &local) const
	Transform direction vector from local to world. More...

geo::Vector_t	toWorldCoords (LocalVector_t const &local) const
	Transform direction vector from local to world. More...

void	WorldToLocal (const double world, double plane) const
	Transform point from world frame to local plane frame. More...

TVector3	WorldToLocal (TVector3 const &world) const
	Transform point from world frame to local plane frame. More...

LocalPoint_t	toLocalCoords (geo::Point_t const &world) const
	Transform point from world frame to local plane frame. More...

void	WorldToLocalVect (const double world, double plane) const
	Transform direction vector from world to local. More...

TVector3	WorldToLocalVect (TVector3 const &world) const
	Transform direction vector from world to local. More...

LocalVector_t	toLocalCoords (geo::Vector_t const &world) const
	Transform direction vector from world to local. More...

Setters
void	SetView (geo::View_t view)
	Set the signal view (for TPCGeo). More...

Static Public Member Functions
static std::string	ViewName (geo::View_t view)
	Returns the name of the specified view. More...

static std::string	OrientationName (geo::Orient_t orientation)
	Returns the name of the specified orientation. More...

Static Public Attributes
static constexpr unsigned int	MaxVerbosity = 6
	Maximum value for print verbosity. More...

Private Types
using	DefaultVector_t = TVector3

using	DefaultPoint_t = TVector3

using	WireCollection_t = std::vector< geo::WireGeo >

using	LocalTransformation_t = geo::LocalTransformationGeo< TGeoHMatrix, LocalPoint_t, LocalVector_t >

Private Member Functions
void	FindWire (GeoNodePath_t &path, size_t depth)

void	MakeWire (GeoNodePath_t &path, size_t depth)

void	DetectGeometryDirections ()
	Sets the geometry directions. More...

geo::Vector_t	GetNormalAxis () const
	Returns a direction normal to the plane (pointing is not defined). More...

void	UpdatePlaneNormal (geo::BoxBoundedGeo const &TPCbox)
	Updates the cached normal to plane versor; needs the TPC box coordinates. More...

void	UpdateWidthDepthDir ()
	Updates the cached depth and width direction. More...

void	UpdateIncreasingWireDir ()
	Updates the cached direction to increasing wires. More...

void	UpdateWireDir ()
	Updates the cached direction to wire. More...

void	UpdateOrientation ()
	Updates plane orientation. More...

void	UpdateWirePitch ()
	Updates the stored wire pitch. More...

void	UpdateWirePlaneCenter ()
	Updates the stored wire plane center. More...

void	UpdatePhiZ ()
	Updates the stored $\phi_{z}$ . More...

void	UpdateView ()
	Updates the stored view. More...

void	UpdateWirePitchSlow ()
	Updates the stored wire pitch with a slower, more robust algorithm. More...

void	UpdateDecompWireOrigin ()
	Updates the position of the wire coordinate decomposition. More...

void	UpdateActiveArea ()
	Updates the internally used active area. More...

bool	shouldFlipWire (geo::WireGeo const &wire) const
	Whether the specified wire should have start and end swapped. More...

Static Private Member Functions
template<typename T >
static T	boundedValue (T v, T min, T max)
	Returns `min` if `v` < `min`, `max` if `v` > `max`, `v` otherwise. More...

Private Attributes
LocalTransformation_t	fTrans
	Plane to world transform. More...

TGeoVolume const *	fVolume
	Plane volume description. More...

View_t	fView
	Does this plane measure U, V, or W? More...

Orient_t	fOrientation
	Is the plane vertical or horizontal? More...

WireCollection_t	fWire
	List of wires in this plane. More...

double	fWirePitch
	Pitch of wires in this plane. More...

double	fSinPhiZ
	Sine of $\phi_{z}$ . More...

double	fCosPhiZ
	Cosine of $\phi_{z}$ . More...

geo::Vector_t	fNormal

WireDecomposer_t	fDecompWire

WidthDepthDecomposer_t	fDecompFrame

RectSpecs	fFrameSize

Rect	fActiveArea
	Area covered by wires in frame base. More...

geo::Point_t	fCenter
	Center of the plane, lying on the wire plane. More...

geo::PlaneID	fID
	ID of this plane. More...

Friends
struct	details::ActiveAreaCalculator

Detailed Description

Geometry information for a single wire plane.

The plane is represented in the geometry by a solid which contains wires. Currently, only box solids are well supported. The box which is representation of the plane has some thickness, and it should not be assumed that the wires are in the median section of it, that is, the center of the box may not lie on the plane defined by the wires.

The plane defines two local reference frames. The first, depending on wire directions and therefore called "wire base", is defined by the normal to the plane (pointing toward the center of the TPC), the direction of the wires, and the direction that the wires measure. This is a positive orthogonal base. Note that for this base to be correctly defined, the Geometry service has to provide external information (for example, where the center of the TPC is).

The second, depending only on the shape of the plane and called "frame base", is defined by the normal (the same as for the previous one), and two orthogonal axes, "width" and "depth", aligned with the sides of the plane. If the plane has not the shape of a box, this reference frame is not available. This coordinate system is also positive defined. These components are all measured in centimeters.

Definition at line 78 of file PlaneGeo.h.

Member Typedef Documentation

using geo::PlaneGeo::DefaultPoint_t = TVector3

private

Definition at line 81 of file PlaneGeo.h.

using geo::PlaneGeo::DefaultVector_t = TVector3

private

Definition at line 80 of file PlaneGeo.h.

using geo::PlaneGeo::GeoNodePath_t = std::vector<TGeoNode const*>

Definition at line 85 of file PlaneGeo.h.

using geo::PlaneGeo::LocalPoint_t = geo::Point3DBase_t<PlaneGeoCoordinatesTag>

Type of points in the local GDML wire plane frame.

Definition at line 106 of file PlaneGeo.h.

using geo::PlaneGeo::LocalTransformation_t = geo::LocalTransformationGeo<TGeoHMatrix, LocalPoint_t, LocalVector_t>

private

Definition at line 1251 of file PlaneGeo.h.

using geo::PlaneGeo::LocalVector_t = geo::Vector3DBase_t<PlaneGeoCoordinatesTag>

Type of displacement vectors in the local GDML wire plane frame.

Definition at line 109 of file PlaneGeo.h.

using geo::PlaneGeo::Rect = lar::util::simple_geo::Rectangle<double>

Type for description of rectangles.

Definition at line 160 of file PlaneGeo.h.

using geo::PlaneGeo::WDDecomposedVector_t = WidthDepthDecomposer_t::DecomposedVector_t

Type describing a 3D point or vector decomposed on a plane with plane frame base (width and depth).

Definition at line 154 of file PlaneGeo.h.

using geo::PlaneGeo::WidthDepthDecomposer_t = geo::Decomposer <geo::Vector_t, geo::Point_t, WidthDepthProjection_t>

Type used for plane decompositions on plane frame (width/depth).

Definition at line 150 of file PlaneGeo.h.

using geo::PlaneGeo::WidthDepthDisplacement_t = ROOT::Math::DisplacementVector2D <ROOT::Math::Cartesian2D<double>, WidthDepthReferenceTag>

Type for vector projections in the plane frame base representation.

Definition at line 146 of file PlaneGeo.h.

using geo::PlaneGeo::WidthDepthProjection_t = ROOT::Math::DisplacementVector2D <ROOT::Math::Cartesian2D<double>, WidthDepthReferenceTag>

Type for projections in the plane frame base representation.

Todo:: the following should be a PositionVector2D

Definition at line 142 of file PlaneGeo.h.

using geo::PlaneGeo::WireCollection_t = std::vector<geo::WireGeo>

private

Definition at line 1248 of file PlaneGeo.h.

using geo::PlaneGeo::WireCoordProjection_t = ROOT::Math::DisplacementVector2D <ROOT::Math::Cartesian2D<double>, WireCoordinateReferenceTag>

Type for projections in the wire base representation.

Definition at line 121 of file PlaneGeo.h.

using geo::PlaneGeo::WireDecomposedVector_t = WireDecomposer_t::DecomposedVector_t

Type describing a 3D point or vector decomposed on a plane on wire base.

Definition at line 128 of file PlaneGeo.h.

using geo::PlaneGeo::WireDecomposer_t = geo::Decomposer <geo::Vector_t, geo::Point_t, WireCoordProjection_t>

Type used for plane decompositions on wire base.

Definition at line 125 of file PlaneGeo.h.

Constructor & Destructor Documentation

geo::PlaneGeo::PlaneGeo	(	GeoNodePath_t &	path,
		size_t	depth
	)

Construct a representation of a single plane of the detector.

Definition at line 435 of file PlaneGeo.cxx.

References DetectGeometryDirections(), FindWire(), fVolume, and UpdateWirePitchSlow().

     : fTrans(path, depth)
     , fVolume(path[depth]->GetVolume())
     , fView(geo::kUnknown)
     , fOrientation(geo::kVertical)
     , fWirePitch(0.)
     , fSinPhiZ(0.)
     , fCosPhiZ(0.)
     , fDecompWire()
     , fDecompFrame()
     , fCenter()
   {
     assert(depth < path.size());
     
     if (!fVolume) {
       TGeoNode const* pNode = path[depth];
       throw cet::exception("PlaneGeo")
         << "Plane geometry node " << pNode->IsA()->GetName()
         << "[" << pNode->GetName() << ", #" << pNode->GetNumber()
         << "] has no volume!\n";
     }
     
     // find the wires for the plane so that you can use them later
     FindWire(path, depth);
     
     // view is now set at TPC level with SetView
     
     DetectGeometryDirections();
     UpdateWirePitchSlow();
     
   } // PlaneGeo::PlaneGeo()

Member Function Documentation

Rect const& geo::PlaneGeo::ActiveArea ( ) const

inline

Returns an area covered by the wires in the plane.

The returned value is conceptually akin of a projection of Coverage() volume. Yet, the precise definition of the area is not specified, therefore this area should not be uses for physics.

The current implementation is documented in details::ActiveAreaCalculator.

Definition at line 613 of file PlaneGeo.h.

References art::detail::indent().

613 { return fActiveArea; }

geo::PlaneGeo::fActiveArea

Rect fActiveArea

Area covered by wires in frame base.

Definition: PlaneGeo.h:1283

template<typename T >

static T geo::PlaneGeo::boundedValue	(	T	v,
		T	min,
		T	max
	)

inlinestaticprivate

Returns min if v < min, max if v > max, v otherwise.

Definition at line 1293 of file PlaneGeo.h.

References ClosestWireID(), max, and min.

1294 { return std::min(max, std::max(min, v)); }

max

Int_t max

Definition: plot.C:27

min

Int_t min

Definition: plot.C:26

geo::BoxBoundedGeo geo::PlaneGeo::BoundingBox ( ) const

Returns the world coordinates of the box containing the plane.

See also: GetBoxCenter()

Definition at line 469 of file PlaneGeo.cxx.

References geo::BoxBoundedGeo::ExtendToInclude(), fVolume, geo::BoxBoundedGeo::SetBoundaries(), and toWorldCoords().

                                                {
     
     //
     // The algorithm is not very refined...
     //
     
     TGeoBBox const* pShape = dynamic_cast<TGeoBBox const*>(fVolume->GetShape());
     if (!pShape) {
       throw cet::exception("PlaneGeo")
         << "BoundingBox(): volume " << fVolume->IsA()->GetName()
         << "['" << fVolume->GetName() << "'] has a shape which is a "
         << pShape->IsA()->GetName()
         << ", not a TGeoBBox!";
     }
     
     geo::BoxBoundedGeo box;
     unsigned int points = 0;
     for (double dx: { -(pShape->GetDX()), +(pShape->GetDX()) }) {
       for (double dy: { -(pShape->GetDY()), +(pShape->GetDY()) }) {
         for (double dz: { -(pShape->GetDZ()), +(pShape->GetDZ()) }) {
           
           auto const p = toWorldCoords(LocalPoint_t{ dx, dy, dz });
           
           if (points++ == 0)
             box.SetBoundaries(p, p);
           else
             box.ExtendToInclude(p);
           
         } // for z
       } // for y
     } // for x
     return box;
     
   } // PlaneGeo::BoundingBox()

geo::WireID geo::PlaneGeo::ClosestWireID ( geo::WireID::WireID_t wireNo ) const

inline

Returns the closest valid wire ID to the specified wire.

Parameters

wireNo number of the wire on this plane

Returns: complete wire ID of the closest wire on this plane

If the wire number described a wire present on this plane, its complete wire ID is returned, valid. Otherwise, a valid wire ID is returned which points to the existing wire closest to the specified wire number: the first wire if the wire number is negative, or the last wire if the wire number is larger than the actual wires.

Note that the argument geo::WireID::WireID_t type is an integral type, and if a floating point value is specified for it, it's subject to truncation.

Definition at line 1305 of file PlaneGeo.h.

Referenced by boundedValue(), and NearestWire().

 {
   return { ID(), boundedValue<geo::WireID::WireID_t>(wireNo, 0, Nwires()) };
 }

geo::WireID geo::PlaneGeo::ClosestWireID ( geo::WireID const & wireid ) const

inline

Returns the closest valid wire ID to the specified wire.

Parameters

wireid the wire ID (must be on this plane)

Returns: complete wire ID of the closest wire, invalid if not this plane

See also: ClosestWireID(geo::WireID::WireID_t)

If wireid is not on this plane, it is returned but marked as invalid. Otherwise, the returned ID is the same as in ClosestWireID(geo::WireID::WireID_t).

Definition at line 1310 of file PlaneGeo.h.

References geo::PlaneID::asPlaneID(), geo::CryostatID::markInvalid(), and geo::WireID::Wire.

 {
   if (wireid.asPlaneID() != ID()) {
     geo::WireID invalid{ wireid };
     invalid.markInvalid();
     return invalid;
   }
   return ClosestWireID(wireid.Wire);
 } // geo::PlaneGeo::ClosestWireID()

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::ComposePoint ( WireDecomposedVector_t const & decomp ) const

inline

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

Template Parameters

Point the type of point to return (current default: TVector3)

Parameters

decomp decomposed point

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

See also: DecomposePoint(), ComposePoint(double, WireCoordProjection_t const&)

See ComposePoint(double, WireCoordProjection_t const&) for details.

Definition at line 818 of file PlaneGeo.h.

Referenced by geo::TPCGeo::ComposePoint(), and larg4::LArVoxelReadout::RecoverOffPlaneDeposit().

819 { return geo::vect::convertTo<Point>(fDecompWire.ComposePoint(decomp)); }

geo::Decomposer::ComposePoint

Point_t ComposePoint(DecomposedVector_t const &decomp) const

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

Definition: Decomposer.h:611

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::ComposePoint	(	double	distance,
		WireCoordProjection_t const &	proj
	)		const

inline

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

Template Parameters

Point the type of point to return (current default: TVector3)

Parameters

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

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

See also: DecomposePoint()

The returned point is the reference point of the frame system (that is, the plane center), 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(). In fact, the strict definition of the result of this method is a 3D point whose decomposition on the plane frame base matches the method arguments.

Note that currently no equivalent facility is available to compose vectors instead of points, that is, entities ignoring the reference point.

Definition at line 847 of file PlaneGeo.h.

848 { return geo::vect::convertTo<Point>(fDecompWire.ComposePoint(distance, proj)); }

geo::Decomposer::ComposePoint

Point_t ComposePoint(DecomposedVector_t const &decomp) const

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

Definition: Decomposer.h:611

proj

Float_t proj

Definition: plot.C:34

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::ComposePoint ( WDDecomposedVector_t const & decomp ) const

inline

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

Template Parameters

Point type of point to be produced (current default is TVector3)

Parameters

decomp decomposed point

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

See also: DecomposePointWidthDepth(), ComposePointWidthDepth(double, DecomposedVector_t::Projection_t const&)

See ComposePointWidthDepth(double, DecomposedVector_t::Projection_t const&) for details.

Definition at line 1083 of file PlaneGeo.h.

1084 { return geo::vect::convertTo<Point>(fDecompFrame.ComposePoint(decomp)); }

geo::Decomposer::ComposePoint

Point_t ComposePoint(DecomposedVector_t const &decomp) const

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

Definition: Decomposer.h:611

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::ComposePoint	(	double	distance,
		WidthDepthProjection_t const &	proj
	)		const

inline

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

Template Parameters

Point type of point to be produced (current default is TVector3)

Parameters

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

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

See also: DecomposePointWidthDepth()

The returned vector is the sum of two 3D vectors:

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

Given the arbitrary definition of the projection reference, it is assumed that the same convention is used as in PointWidthDepthProjection() and DecomposePointWidthDepth().

Definition at line 1107 of file PlaneGeo.h.

1108 { return geo::vect::convertTo<Point>(fDecompFrame.ComposePoint(distance, proj)); }

geo::Decomposer::ComposePoint

Point_t ComposePoint(DecomposedVector_t const &decomp) const

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

Definition: Decomposer.h:611

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

proj

Float_t proj

Definition: plot.C:34

double geo::PlaneGeo::CosPhiZ ( ) const

inline

Cosine of PhiZ()

Definition at line 187 of file PlaneGeo.h.

187 { return fCosPhiZ; }

geo::PlaneGeo::fCosPhiZ

double fCosPhiZ

Cosine of .

Definition: PlaneGeo.h:1270

lar::util::simple_geo::Volume geo::PlaneGeo::Coverage ( ) const

Returns a volume including all the wires in the plane.

Definition at line 566 of file PlaneGeo.cxx.

References B, DeltaFromPlane(), FirstWire(), geo::WireGeo::GetEnd(), geo::WireGeo::GetStart(), and LastWire().

                                                      {
     
     // add both coordinates of first and last wire
     std::array<double, 3> A, B;
     
     FirstWire().GetStart(A.data());
     LastWire().GetEnd(B.data());
     
     return { A.data(), B.data() };
   } // PlaneGeo::Coverage()

WireDecomposedVector_t geo::PlaneGeo::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 plane, expressed as a signed real number
a component lying on the plane, expressed as a 2D vector

The distance is obtained as by DistanceFromPlane(). The projection on the plane is obtained following the same convention as PointProjection().

Definition at line 744 of file PlaneGeo.h.

745 { return fDecompWire.DecomposePoint(point); }

geo::Decomposer::DecomposePoint

DecomposedVector_t DecomposePoint(Point_t const &point) const

Decomposes a 3D point in two components.

Definition: Decomposer.h:517

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

WireDecomposedVector_t geo::PlaneGeo::DecomposePoint ( TVector3 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 plane, expressed as a signed real number
a component lying on the plane, expressed as a 2D vector

The distance is obtained as by DistanceFromPlane(). The projection on the plane is obtained following the same convention as PointProjection().

Definition at line 746 of file PlaneGeo.h.

References geo::vect::toPoint().

747 { 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:1281

geo::PlaneGeo::DecomposePoint

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

Decomposes a 3D point in two components.

Definition: PlaneGeo.h:744

WDDecomposedVector_t geo::PlaneGeo::DecomposePointWidthDepth ( 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 plane, expressed as a signed real number
a component lying on the plane, expressed as a 2D vector

The distance is obtained as by DistanceFromPlane(). The projection on the plane is obtained following the same convention as PointWidthDepthProjection().

Definition at line 878 of file PlaneGeo.h.

Referenced by geo::TPCGeo::DecomposePoint().

879 { return fDecompFrame.DecomposePoint(point); }

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

geo::Decomposer::DecomposePoint

DecomposedVector_t DecomposePoint(Point_t const &point) const

Decomposes a 3D point in two components.

Definition: Decomposer.h:517

WDDecomposedVector_t geo::PlaneGeo::DecomposePointWidthDepth ( TVector3 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 plane, expressed as a signed real number
a component lying on the plane, expressed as a 2D vector

The distance is obtained as by DistanceFromPlane(). The projection on the plane is obtained following the same convention as PointWidthDepthProjection().

Definition at line 880 of file PlaneGeo.h.

References geo::vect::toPoint().

881 { return DecomposePointWidthDepth(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:1281

geo::PlaneGeo::DecomposePointWidthDepth

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

Decomposes a 3D point in two components.

Definition: PlaneGeo.h:878

PlaneGeo::WidthDepthProjection_t geo::PlaneGeo::DeltaFromActivePlane	(	WidthDepthProjection_t const &	proj,
		double	wMargin,
		double	dMargin
	)		const

Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the active area of plane.

Parameters

proj	starting projection
wMargin	the point is brought this amount inside the active area
dMargin	the point is brought this amount inside the active area

Returns: a projection displacement

See also: DeltaFromPlane()

The "active" area of the plane is the rectangular area which includes all the wires. The area is obtained as the smallest rectangle including the projection of both ends of all wires in the plane, less half a pitch. This defines a "fiducial" area away from the borders of the plane. The projection is in the frame reference (PointWidthDepthProjection()). The area is reduced on each side by the specified margins. If for example wMargin is 1.0, the active area lower border on the width direction will be increased by 1 cm, and the upper border will be decreased by 1 cm effectively making the active area 2 cm narrowed on the width direction. The same independently applies to the depth direction with dMargin. The main purpose of the margins is to accommodate for rounding errors. A version of this method with default margins of 0 is also available.

If the projection is already on the active area of the plane, the returned displacement is null. Otherwise, the displacement, added to proj, will bring it on the active plane area (in fact, on its border).

Definition at line 593 of file PlaneGeo.cxx.

References lar::util::simple_geo::Range< Data >::delta(), lar::util::simple_geo::Rectangle< Data >::depth, fActiveArea, and lar::util::simple_geo::Rectangle< Data >::width.

Referenced by DeltaFromPlane(), and larg4::LArVoxelReadout::RecoverOffPlaneDeposit().

   {
     
     return {
       fActiveArea.width.delta(proj.X(), wMargin),
       fActiveArea.depth.delta(proj.Y(), dMargin)
       };
     
   } // PlaneGeo::DeltaFromActivePlane()

WidthDepthProjection_t geo::PlaneGeo::DeltaFromActivePlane	(	WidthDepthProjection_t const &	proj,
		double	margin = `0.0`
	)		const

inline

Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the active area of plane.

Parameters

proj	starting projection
margin	the point is brought this amount inside the active area _(default: 0)_

Returns: a projection displacement

See also: DeltaFromActivePlane(WidthDepthProjection_t const&, double, double)

This is the implementation with default values for margins of DeltaFromActivePlane(). The depth and width margins are the same, and 0 by default.

Definition at line 1032 of file PlaneGeo.h.

1033 { return DeltaFromActivePlane(proj, margin, margin); }

geo::PlaneGeo::DeltaFromActivePlane

WidthDepthProjection_t DeltaFromActivePlane(WidthDepthProjection_t const &proj, double wMargin, double dMargin) const

Returns a projection vector that, added to the argument, gives a projection inside (or at the border ...

Definition: PlaneGeo.cxx:593

proj

Float_t proj

Definition: plot.C:34

PlaneGeo::WidthDepthProjection_t geo::PlaneGeo::DeltaFromPlane	(	WidthDepthProjection_t const &	proj,
		double	wMargin,
		double	dMargin
	)		const

Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the plane.

Parameters

proj	starting projection
wMargin	the point is brought this amount inside the target area
dMargin	the point is brought this amount inside the target area

Returns: a projection displacement

See also: DeltaFromActivePlane()

The returned projection vector is guaranteed, when added to proj, to yield a projection on or within the border of the plane (the "target area"), as defined by the GDML geometry.

The target plane area is reduced on each side by the specified margins. If for example wMargin is 1.0, the area lower border on the width direction will be increased by 1 cm, and the upper border will be decreased by 1 cm effectively making the area 2 cm narrowed on the width direction. The same independently applies to the depth direction with dMargin. The main purpose of the margins is to accommodate for rounding errors. A version of this method with default margins of 0 is also available.

If the projection is already on the target area, the returned displacement is null.

Definition at line 580 of file PlaneGeo.cxx.

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

Referenced by Coverage(), isProjectionOnPlane(), MovePointOverPlane(), and MoveProjectionToPlane().

   {
     
     return {
       symmetricCapDelta(proj.X(), fFrameSize.HalfWidth() - wMargin),
       symmetricCapDelta(proj.Y(), fFrameSize.HalfDepth() - dMargin)
     };
     
   } // PlaneGeo::DeltaFromPlane()

WidthDepthProjection_t geo::PlaneGeo::DeltaFromPlane	(	WidthDepthProjection_t const &	proj,
		double	margin = `0.0`
	)		const

inline

Returns a projection vector that, added to the argument, gives a projection inside (or at the border of) the area of plane.

Parameters

proj	starting projection
margin	the point is brought this amount inside the plane area _(default: 0)_

Returns: a projection displacement

See also: DeltaFromPlane(WidthDepthProjection_t const&, double, double)

This is the implementation with default values for margins of DeltaFromPlane(). The depth and width margins are the same, and 0 by default.

Definition at line 984 of file PlaneGeo.h.

985 { return DeltaFromPlane(proj, margin, margin); }

geo::PlaneGeo::DeltaFromPlane

WidthDepthProjection_t DeltaFromPlane(WidthDepthProjection_t const &proj, double wMargin, double dMargin) const

Returns a projection vector that, added to the argument, gives a projection inside (or at the border ...

Definition: PlaneGeo.cxx:580

proj

Float_t proj

Definition: plot.C:34

double geo::PlaneGeo::Depth ( ) const

inline

Return the depth of the plane.

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

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

Definition at line 235 of file PlaneGeo.h.

235 { return fFrameSize.Depth(); }

geo::PlaneGeo::RectSpecs::Depth

double Depth() const

Definition: PlaneGeo.h:1260

geo::PlaneGeo::fFrameSize

RectSpecs fFrameSize

Definition: PlaneGeo.h:1281

template<typename Vector = DefaultVector_t>

Vector geo::PlaneGeo::DepthDir ( ) const

inline

Return the direction of plane depth.

Template Parameters

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

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 219 of file PlaneGeo.h.

Referenced by MovePointOverPlane(), geo::TPCGeo::RefDepthDir(), and UpdateWidthDepthDir().

219 { return geo::vect::convertTo<Vector>(fDecompFrame.SecondaryDir()); }

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

geo::Decomposer::SecondaryDir

Vector_t const & SecondaryDir() const

Returns the plane secondary axis direction.

Definition: Decomposer.h:466

void geo::PlaneGeo::DetectGeometryDirections ( )

private

Sets the geometry directions.

Definition at line 790 of file PlaneGeo.cxx.

References dir, e, fDecompFrame, fFrameSize, fVolume, geo::PlaneGeo::RectSpecs::halfDepth, geo::PlaneGeo::RectSpecs::halfWidth, geo::origin(), geo::vect::rounded01(), geo::Decomposer< Vector, Point, ProjVector >::SetMainDir(), geo::Decomposer< Vector, Point, ProjVector >::SetOrigin(), geo::Decomposer< Vector, Point, ProjVector >::SetSecondaryDir(), toWorldCoords(), and Z.

Referenced by PlaneGeo().

                                           {
     
     //
     // We need to identify which are the "long" directions of the plane.
     // We assume it is a box, and the shortest side is excluded.
     // The first direction ("width") is given by preference to z.
     // If z is the direction of the normal to the plane... oh well.
     // Let's say privilege to the one which comes from local z, then y.
     // That means: undefined.
     // 
     // Requirements:
     //  - ROOT geometry information (shapes and transformations)
     //  - the shape must be a box (an error is PRINTED if not)
     //  - center of the wire plane (not just the center of the plane box)
     //
     
     //
     // how do they look like in the world?
     //
     TGeoBBox const* pShape = dynamic_cast<TGeoBBox const*>(fVolume->GetShape());
     if (!pShape) {
       mf::LogError("BoxInfo")
         << "Volume " << fVolume->IsA()->GetName() << "['" << fVolume->GetName()
         << "'] has a shape which is a " << pShape->IsA()->GetName()
         << ", not a TGeoBBox! Dimensions won't be available.";
       // set it invalid
       fDecompFrame.SetOrigin(geo::origin());
       fDecompFrame.SetMainDir({ 0., 0., 0. });
       fDecompFrame.SetSecondaryDir({ 0., 0., 0. });
       fFrameSize = { 0.0, 0.0 };
       return;
     }
     
     std::array<geo::Vector_t, 3U> sides;
     size_t iSmallest = 3;
     {
       
       size_t iSide = 0;
       TVector3 dir;
       
       sides[iSide] = toWorldCoords(LocalVector_t{ pShape->GetDX(), 0.0, 0.0 });
       iSmallest = iSide;
       ++iSide;
       
       sides[iSide] = toWorldCoords(LocalVector_t{ 0.0, pShape->GetDY(), 0.0 });
       if (sides[iSide].Mag2() < sides[iSmallest].Mag2()) iSmallest = iSide;
       ++iSide;
       
       sides[iSide] = toWorldCoords(LocalVector_t{ 0.0, 0.0, pShape->GetDZ() });
       if (sides[iSide].Mag2() < sides[iSmallest].Mag2()) iSmallest = iSide;
       ++iSide;
       
     }
     
     //
     // which are the largest ones?
     //
     size_t kept[2];
     {
       size_t iKept = 0;
       for (size_t i = 0; i < 3; ++i) if (i != iSmallest) kept[iKept++] = i;
     }
     
     //
     // which is which?
     // 
     // Pick width as the most z-like.
     //
     size_t const iiWidth =
       std::abs(sides[kept[0]].Unit().Z()) > std::abs(sides[kept[1]].Unit().Z())
       ? 0: 1;
     size_t const iWidth = kept[iiWidth];
     size_t const iDepth = kept[1 - iiWidth]; // the other
     
     fDecompFrame.SetMainDir(geo::vect::rounded01(sides[iWidth].Unit(), 1e-4));
     fDecompFrame.SetSecondaryDir
       (geo::vect::rounded01(sides[iDepth].Unit(), 1e-4));
     fFrameSize.halfWidth = sides[iWidth].R();
     fFrameSize.halfDepth = sides[iDepth].R();
     
   } // PlaneGeo::DetectGeometryDirections()

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

inline

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

Parameters

point a point in world coordinates [cm]

Returns: the signed distance from the wire plane

The distance is defined positive if the point lies in the side the normal vector (GetNormalDirection()) points to.

The distance is defined from the geometric plane where the wires lie, and it may not match the distance from the center of the geometry box representing the plane. It should always match the drift distance from this wire plane, and the result of DriftPoint(point, DistanceFromPlane(point)) will bring the point to the plane.

Definition at line 557 of file PlaneGeo.h.

Referenced by geo::TPCGeo::ComputeDriftDistance(), geo::TPCGeo::DistanceFromReferencePlane(), larg4::LArVoxelReadout::RecoverOffPlaneDeposit(), and UpdateWirePlaneCenter().

558 { return fDecompWire.PointNormalComponent(point); }

geo::Decomposer::PointNormalComponent

auto PointNormalComponent(Point_t const &point) const

Returns the secondary component of a point.

Definition: Decomposer.h:486

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

double geo::PlaneGeo::DistanceFromPlane ( TVector3 const & point ) const

inline

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

Parameters

point a point in world coordinates [cm]

Returns: the signed distance from the wire plane

The distance is defined positive if the point lies in the side the normal vector (GetNormalDirection()) points to.

The distance is defined from the geometric plane where the wires lie, and it may not match the distance from the center of the geometry box representing the plane. It should always match the drift distance from this wire plane, and the result of DriftPoint(point, DistanceFromPlane(point)) will bring the point to the plane.

Definition at line 559 of file PlaneGeo.h.

References geo::vect::toPoint().

560 { return DistanceFromPlane(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:1281

geo::PlaneGeo::DistanceFromPlane

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

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

Definition: PlaneGeo.h:557

void geo::PlaneGeo::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]

This is a pure geometry computation: the position is shifted by the drift distance in the direction opposite to the normal to the plane (as returned by GetNormalDirection()), no matter where the position is relative to the plane. The wording about "electron position" is just meant to remind that the drift shift is taken with opposite sign: since the point is assumed to be an electron, a positive drift normally moves its position toward the wire plane.

Definition at line 579 of file PlaneGeo.h.

Referenced by geo::TPCGeo::DriftPoint(), and UpdateWirePlaneCenter().

580 { position -= distance * GetNormalDirection<geo::Vector_t>(); }

void geo::PlaneGeo::DriftPoint	(	TVector3 &	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]

This is a pure geometry computation: the position is shifted by the drift distance in the direction opposite to the normal to the plane (as returned by GetNormalDirection()), no matter where the position is relative to the plane. The wording about "electron position" is just meant to remind that the drift shift is taken with opposite sign: since the point is assumed to be an electron, a positive drift normally moves its position toward the wire plane.

Definition at line 581 of file PlaneGeo.h.

582 { position -= distance * GetNormalDirection(); }

geo::PlaneGeo::GetNormalDirection

Vector GetNormalDirection() const

Returns the direction normal to the plane.

Definition: PlaneGeo.h:397

void geo::PlaneGeo::DriftPoint ( geo::Point_t & position ) const

inline

Shifts the position along drift direction to fall on the plane.

Parameters

position _(modified)_ the position to be shifted

This is a pure geometry computation: the position is shifted by the drift distance in the direction opposite to the normal to the plane (as returned by GetNormalDirection()), no matter where the position is relative to the plane.

Definition at line 595 of file PlaneGeo.h.

596 { DriftPoint(position, DistanceFromPlane(position)); }

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:579

geo::PlaneGeo::DistanceFromPlane

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

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

Definition: PlaneGeo.h:557

void geo::PlaneGeo::DriftPoint ( TVector3 & position ) const

inline

Shifts the position along drift direction to fall on the plane.

Parameters

position _(modified)_ the position to be shifted

This is a pure geometry computation: the position is shifted by the drift distance in the direction opposite to the normal to the plane (as returned by GetNormalDirection()), no matter where the position is relative to the plane.

Definition at line 597 of file PlaneGeo.h.

598 { DriftPoint(position, DistanceFromPlane(position)); }

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:579

geo::PlaneGeo::DistanceFromPlane

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

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

Definition: PlaneGeo.h:557

void geo::PlaneGeo::FindWire	(	GeoNodePath_t &	path,
		size_t	depth
	)

private

Definition at line 517 of file PlaneGeo.cxx.

References MakeWire().

Referenced by PlaneGeo().

   {
     // Check if the current node is a wire
     const char* wireLabel = "volTPCWire";
     auto const labelLength = strlen(wireLabel);
     if(strncmp(path[depth]->GetName(), wireLabel, labelLength) == 0){
       MakeWire(path, depth);
       return;
     }
   
     // Explore the next layer down
     unsigned int deeper = depth+1;
     if (deeper>=path.size()) {
       throw cet::exception("ExceededMaxDepth") << "Exceeded maximum depth\n";
     }
     const TGeoVolume* v = path[depth]->GetVolume();
     int nd = v->GetNdaughters();
     for (int i=0; i<nd; ++i) {
       path[deeper] = v->GetNode(i);
       FindWire(path, deeper);
     }
   }

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

inline

Return the first wire in the plane.

Definition at line 325 of file PlaneGeo.h.

Referenced by Coverage(), geo::details::ActiveAreaCalculator::initializeWireEnds(), ThetaZ(), UpdateDecompWireOrigin(), and UpdateWireDir().

325 { return Wire(0); }

geo::PlaneGeo::Wire

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:506

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::GetBoxCenter ( ) const

inline

Returns the centre of the box representing the plane.

Template Parameters

Point type of point to be returned (current default: TVector3)

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 441 of file PlaneGeo.h.

Referenced by geo::TPCGeo::DetectDriftDirection(), geo::TPCGeo::ResetDriftDirection(), and UpdatePlaneNormal().

442 { return geo::vect::convertTo<Point>(toWorldCoords(LocalPoint_t{ 0.0, 0.0, 0.0 })); }

geo::PlaneGeo::toWorldCoords

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

Transform point from local plane frame to world frame.

Definition: PlaneGeo.h:1132

geo::PlaneGeo::LocalPoint_t

geo::Point3DBase_t< PlaneGeoCoordinatesTag > LocalPoint_t

Type of points in the local GDML wire plane frame.

Definition: PlaneGeo.h:106

template<typename Point = DefaultPoint_t>

Point 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 426 of file PlaneGeo.h.

Referenced by geo::DriftPartitions::computeCoverage(), geo::TPCGeo::ProjectionReferencePoint(), UpdateDecompWireOrigin(), and UpdateIncreasingWireDir().

427 { return geo::vect::convertTo<Point>(fCenter); }

geo::PlaneGeo::fCenter

geo::Point_t fCenter

Center of the plane, lying on the wire plane.

Definition: PlaneGeo.h:1285

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 296 of file PlaneGeo.h.

297 { return Wire(wireid); }

geo::PlaneGeo::Wire

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:506

WireGeo const* 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 319 of file PlaneGeo.h.

320 { return WirePtr(wireid); }

geo::PlaneGeo::WirePtr

WireGeo const * WirePtr(unsigned int iwire) const

Returns the wire number iwire from this plane.

Definition: PlaneGeo.h:305

template<typename Vector = DefaultVector_t>

Vector geo::PlaneGeo::GetIncreasingWireDirection ( ) const

inline

Returns the direction of increasing wires.

Template Parameters

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

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 408 of file PlaneGeo.h.

Referenced by geo::details::ActiveAreaCalculator::adjustCorners(), shouldFlipWire(), UpdatePhiZ(), and WireIDincreasesWithZ().

409 { return geo::vect::convertTo<Vector>(fDecompWire.SecondaryDir()); }

geo::Decomposer::SecondaryDir

Vector_t const & SecondaryDir() const

Returns the plane secondary axis direction.

Definition: Decomposer.h:466

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

geo::Vector_t geo::PlaneGeo::GetNormalAxis ( ) const

private

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

Definition at line 873 of file PlaneGeo.cxx.

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

Referenced by UpdatePlaneNormal().

                                             {
     const unsigned 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<geo::Vector_t>();
     
     // 2) get the direction between the middle wire and the next one
     auto const ToNextWire = Wire(NWires / 2 + 1).GetCenter<geo::Point_t>()
       - Wire(NWires / 2).GetCenter<geo::Point_t>();
     
     // 3) get the direction perpendicular to the plane
     // 4) round it
     // 5) return its norm
     return geo::vect::rounded01(WireDir.Cross(ToNextWire).Unit(), 1e-4);
     
   } // PlaneGeo::GetNormalAxis()

template<typename Vector = DefaultVector_t>

Vector geo::PlaneGeo::GetNormalDirection ( ) const

inline

Returns the direction normal to the plane.

Template Parameters

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

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 397 of file PlaneGeo.h.

Referenced by shouldFlipWire(), and UpdateWidthDepthDir().

397 { return geo::vect::convertTo<Vector>(fNormal); }

geo::PlaneGeo::fNormal

geo::Vector_t fNormal

Definition: PlaneGeo.h:1272

template<typename Vector = DefaultVector_t>

Vector geo::PlaneGeo::GetWireDirection ( ) const

inline

Returns the direction of the wires.

Template Parameters

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

Returns: a unit vector following the direction of the wires

All wires in the plane are assumed parallel.

Definition at line 452 of file PlaneGeo.h.

452 { return geo::vect::convertTo<Vector>(fDecompWire.MainDir()); }

geo::Decomposer::MainDir

Vector_t const & MainDir() const

Returns the plane main axis direction.

Definition: Decomposer.h:463

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

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 261 of file PlaneGeo.h.

261 { return HasWire(iwire); }

geo::PlaneGeo::HasWire

bool HasWire(unsigned int iwire) const

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

Definition: PlaneGeo.h:260

bool geo::PlaneGeo::HasElement ( geo::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 275 of file PlaneGeo.h.

276 { return HasWire(wireid); }

geo::PlaneGeo::HasWire

bool HasWire(unsigned int iwire) const

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

Definition: PlaneGeo.h:260

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 260 of file PlaneGeo.h.

Referenced by geo::GeometryCore::HasWire().

260 { return iwire < Nwires(); }

geo::PlaneGeo::Nwires

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:250

bool geo::PlaneGeo::HasWire ( geo::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 273 of file PlaneGeo.h.

References geo::WireID::Wire.

274 { return HasWire(wireid.Wire); }

geo::PlaneGeo::HasWire

bool HasWire(unsigned int iwire) const

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

Definition: PlaneGeo.h:260

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

inline

Returns the identifier of this plane.

Definition at line 190 of file PlaneGeo.h.

Referenced by NearestWire(), NearestWireID(), geo::GeometryCore::Print(), and geo::TPCGeo::ReferencePlaneID().

190 { return fID; }

geo::PlaneGeo::fID

geo::PlaneID fID

ID of this plane.

Definition: PlaneGeo.h:1287

bool geo::PlaneGeo::isProjectionOnPlane ( geo::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 605 of file PlaneGeo.cxx.

References DeltaFromPlane(), MoveProjectionToPlane(), and PointWidthDepthProjection().

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

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

inline

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 937 of file PlaneGeo.h.

References geo::vect::toPoint().

938 { return isProjectionOnPlane(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:1281

geo::PlaneGeo::isProjectionOnPlane

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

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

Definition: PlaneGeo.cxx:605

auto geo::PlaneGeo::IterateWires ( ) const

inline

Allows range-for iteration on all wires in this plane.

Returns: an object suitable for range-for iteration on all wires

This example uses geometry to iterate on all planes in an outer loop, and then iterates on all wires in the plane in the inner loop:

auto geom = lar::providerFrom<geo::Geometry>();
for (geo::PlaneGeo const& plane: geom->IteratePlanes()) {
  // collect plane information
  for (geo::WireGeo const& wire: plane.IterateWires()) {
    // do something with each single wire
  }
} // for planes

(note that all data types here can be replaced with auto).

Definition at line 357 of file PlaneGeo.h.

358 { return fWire; }

geo::PlaneGeo::fWire

WireCollection_t fWire

List of wires in this plane.

Definition: PlaneGeo.h:1267

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

inline

Return the last wire in the plane.

Definition at line 331 of file PlaneGeo.h.

Referenced by Coverage(), and geo::details::ActiveAreaCalculator::initializeWireEnds().

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

geo::PlaneGeo::Wire

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:506

geo::PlaneGeo::Nwires

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:250

void geo::PlaneGeo::LocalToWorld	(	const double *	plane,
		double *	world
	)		const

inline

Transform point from local plane frame to world frame.

Definition at line 1124 of file PlaneGeo.h.

Referenced by hit::GausHitFinderAna::analyze(), evd::RecoBaseDrawer::DrawTrack2D(), evd::TWQMultiTPCProjectionView::FindEndPoint(), evd::TWQProjectionView::FindEndPoint(), evd::TWQMultiTPCProjectionView::FindLineLength(), evd::TWQProjectionView::FindLineLength(), util::GeometryUtilities::Get2DPointProjection(), util::GeometryUtilities::GetProjectedPoint(), util::GeometryUtilities::GetTimeTicks(), util::GeometryUtilities::GetXYZ(), cluster::ClusterCheater::produce(), shwf::ShowerReco::produce(), detsim::SimWire::SetFieldResponse(), detsim::SimWireT962::SetFieldResponse(), and geo::sortPlaneStandard().

1125 { fTrans.LocalToWorld(plane, world); }

geo::LocalTransformation::LocalToWorld

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

Transforms a point from local frame to world frame.

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

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

inline

Transform point from local plane frame to world frame.

Definition at line 1128 of file PlaneGeo.h.

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

geo::LocalTransformation::LocalToWorld

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

Transforms a point from local frame to world frame.

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

void geo::PlaneGeo::LocalToWorldVect	(	const double *	plane,
		double *	world
	)		const

inline

Transform direction vector from local to world.

Definition at line 1136 of file PlaneGeo.h.

1137 { fTrans.LocalToWorldVect(plane, world); }

geo::LocalTransformation::LocalToWorldVect

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

Transforms a vector from local frame to world frame.

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

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

inline

Transform direction vector from local to world.

Definition at line 1140 of file PlaneGeo.h.

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

geo::LocalTransformation::LocalToWorldVect

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

Transforms a vector from local frame to world frame.

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

void geo::PlaneGeo::MakeWire	(	GeoNodePath_t &	path,
		size_t	depth
	)

private

Definition at line 542 of file PlaneGeo.cxx.

References fWire.

Referenced by FindWire().

   {
     fWire.emplace_back(path, depth);
   }

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

inline

Return the middle wire in the plane.

Definition at line 328 of file PlaneGeo.h.

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

geo::PlaneGeo::Wire

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:506

geo::PlaneGeo::Nwires

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:250

geo::Point_t geo::PlaneGeo::MovePointOverPlane ( geo::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 657 of file PlaneGeo.cxx.

References DeltaFromPlane(), and PointWidthDepthProjection().

                                                                        {
     
     //
     // 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<geo::Vector_t>() + deltaProj.Y() * DepthDir<geo::Vector_t>();
     
   } // PlaneGeo::MovePointOverPlane()

TVector3 geo::PlaneGeo::MovePointOverPlane ( TVector3 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 643 of file PlaneGeo.cxx.

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

                                                                    {
     
     //
     // 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::MovePointOverPlane()

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 617 of file PlaneGeo.cxx.

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

Referenced by isProjectionOnPlane().

   {
     //
     // We have a more complicate 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()
         )
       };
     
   } // PlaneGeo::MoveProjectionToPlane()

geo::WireGeo const & geo::PlaneGeo::NearestWire ( geo::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 705 of file PlaneGeo.cxx.

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

                                                                        {
     
     //
     // 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.
     //
     
     geo::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!
     geo::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";
     
   } // PlaneGeo::NearestWire()

geo::WireID geo::PlaneGeo::NearestWireID ( geo::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 673 of file PlaneGeo.cxx.

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

Referenced by NearestWire(), and geo::GeometryCore::NearestWireID().

                                                                {
     
     //
     // 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(), (geo::WireID::WireID_t) nearestWireNo };
     
   } // PlaneGeo::NearestWireID()

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

inline

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

Definition at line 481 of file PlaneGeo.h.

References geo::vect::toPoint().

482 { return NearestWireID(geo::vect::toPoint(pos)); }

geo::vect::toPoint

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

Convert the specified point into a geo::Point_t.

Definition: geo_vectors_utils.h:1281

geo::PlaneGeo::NearestWireID

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

Returns the ID of wire closest to the specified position.

Definition: PlaneGeo.cxx:673

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

inline

Number of wires in this plane.

Definition at line 251 of file PlaneGeo.h.

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

251 { return Nwires(); }

geo::PlaneGeo::Nwires

unsigned int Nwires() const

Number of wires in this plane.

Definition: PlaneGeo.h:250

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

inline

Number of wires in this plane.

Definition at line 250 of file PlaneGeo.h.

Referenced by hit::DisambigCheater::DisambigCheater(), cluster::EndPointAlg::EndPoint(), cluster::HoughBaseAlg::FastTransform(), GetNormalAxis(), geo::ChannelMapStandardAlg::Initialize(), NearestWireID(), geo::GeometryCore::Print(), vertex::HarrisVertexFinder::produce(), evd::RecoBaseDrawer::RecoBaseDrawer(), cluster::HoughBaseAlg::Transform(), and UpdateIncreasingWireDir().

250 { return fWire.size(); }

geo::PlaneGeo::fWire

WireCollection_t fWire

List of wires in this plane.

Definition: PlaneGeo.h:1267

Orient_t geo::PlaneGeo::Orientation ( ) const

inline

What is the orientation of the plane.

Definition at line 174 of file PlaneGeo.h.

Referenced by trkf::SpacePointAlg::update().

174 { return fOrientation; }

geo::PlaneGeo::fOrientation

Orient_t fOrientation

Is the plane vertical or horizontal?

Definition: PlaneGeo.h:1266

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

static

Returns the name of the specified orientation.

Definition at line 780 of file PlaneGeo.cxx.

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

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

double geo::PlaneGeo::PhiZ ( ) const

inline

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

Definition at line 180 of file PlaneGeo.h.

Referenced by geo::GeometryCore::ThirdPlane_dTdW(), and geo::GeometryCore::ThirdPlaneSlope().

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

geo::PlaneGeo::fSinPhiZ

double fSinPhiZ

Sine of .

Definition: PlaneGeo.h:1269

geo::PlaneGeo::fCosPhiZ

double fCosPhiZ

Cosine of .

Definition: PlaneGeo.h:1270

double geo::PlaneGeo::PlaneCoordinate ( geo::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 704 of file PlaneGeo.h.

Referenced by pma::GetProjectionToPlane(), and pma::Node3D::UpdateProj2D().

705 { return fDecompWire.PointSecondaryComponent(point); }

geo::Decomposer::PointSecondaryComponent

auto PointSecondaryComponent(Point_t const &point) const

Returns the secondary component of a point.

Definition: Decomposer.h:482

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

double geo::PlaneGeo::PlaneCoordinate ( TVector3 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 706 of file PlaneGeo.h.

References geo::vect::toPoint().

707 { return PlaneCoordinate(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:1281

geo::PlaneGeo::PlaneCoordinate

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

Returns the coordinate of the point on the plane.

Definition: PlaneGeo.h:704

double geo::PlaneGeo::PlaneCoordinateFrom	(	geo::Point_t const &	point,
		geo::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 677 of file PlaneGeo.h.

References geo::WireGeo::GetCenter(), and geo::vect::toPoint().

       {
         return
           fDecompWire.VectorSecondaryComponent(point - geo::vect::toPoint(refWire.GetCenter()));
       }

double geo::PlaneGeo::PlaneCoordinateFrom	(	TVector3 const &	point,
		geo::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 683 of file PlaneGeo.h.

References geo::vect::toPoint().

684 { return PlaneCoordinateFrom(geo::vect::toPoint(point), refWire); }

geo::vect::toPoint

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

Convert the specified point into a geo::Point_t.

Definition: geo_vectors_utils.h:1281

geo::PlaneGeo::PlaneCoordinateFrom

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

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

Definition: PlaneGeo.h:677

WireCoordProjection_t geo::PlaneGeo::PointProjection ( 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 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 781 of file PlaneGeo.h.

782 { return Projection(point); }

geo::PlaneGeo::Projection

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

Returns the projection of the specified point on the plane.

Definition: PlaneGeo.h:779

WireCoordProjection_t geo::PlaneGeo::PointProjection ( TVector3 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 783 of file PlaneGeo.h.

References geo::vect::toPoint().

784 { return PointProjection(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:1281

geo::PlaneGeo::PointProjection

WireCoordProjection_t PointProjection(geo::Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: PlaneGeo.h:781

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

Referenced by geo::details::ActiveAreaCalculator::initializeWireEnds(), isProjectionOnPlane(), MovePointOverPlane(), geo::TPCGeo::Projection(), and larg4::LArVoxelReadout::RecoverOffPlaneDeposit().

898 { return fDecompFrame.ProjectPointOnPlane(point); }

geo::Decomposer::ProjectPointOnPlane

Projection_t ProjectPointOnPlane(Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: Decomposer.h:500

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

WidthDepthProjection_t geo::PlaneGeo::PointWidthDepthProjection ( TVector3 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 900 of file PlaneGeo.h.

References geo::vect::toPoint().

901 { return PointWidthDepthProjection(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:1281

geo::PlaneGeo::PointWidthDepthProjection

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

Returns the projection of the specified point on the plane.

Definition: PlaneGeo.h:897

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 1324 of file PlaneGeo.h.

Referenced by geo::GeometryCore::Print().

         {
   
   //----------------------------------------------------------------------------
   out << "plane " << std::string(ID());
   
   if (verbosity-- <= 0) return; // 0
   
   //----------------------------------------------------------------------------
   out
     << " at " << GetCenter<geo::Vector_t>() << " 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<geo::Vector_t>();
   auto const& incrZdir = GetIncreasingWireDirection<geo::Vector_t>();
   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<geo::Vector_t>();
   auto const& widthDir = WidthDir<geo::Vector_t>();
   auto const& depthDir = DepthDir<geo::Vector_t>();
   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();
   
 //  if (verbosity-- <= 0) return; // 6
   
   //----------------------------------------------------------------------------
 } // geo::PlaneGeo::PrintPlaneInfo()

WireCoordProjection_t geo::PlaneGeo::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 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 779 of file PlaneGeo.h.

780 { return fDecompWire.ProjectPointOnPlane(point); }

geo::Decomposer::ProjectPointOnPlane

Projection_t ProjectPointOnPlane(Point_t const &point) const

Returns the projection of the specified point on the plane.

Definition: Decomposer.h:500

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

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

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 800 of file PlaneGeo.h.

801 { return fDecompWire.ProjectVectorOnPlane(v); }

geo::Decomposer::ProjectVectorOnPlane

Projection_t ProjectVectorOnPlane(Vector_t const &v) const

Returns the projection of the specified vector on the plane.

Definition: Decomposer.h:549

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

template<typename Point = DefaultPoint_t>

Point geo::PlaneGeo::ProjectionReferencePoint ( ) const

inline

Returns the reference point used by PointProjection().

Template Parameters

Point the type of point to return (current default: TVector3)

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

Definition at line 759 of file PlaneGeo.h.

760 { return geo::vect::convertTo<Point>(fDecompWire.ReferencePoint()); }

geo::Decomposer::ReferencePoint

Point_t ReferencePoint() const

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

Definition: Decomposer.h:457

geo::PlaneGeo::fDecompWire

WireDecomposer_t fDecompWire

Definition: PlaneGeo.h:1276

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

inline

Set the signal view (for TPCGeo).

Definition at line 1179 of file PlaneGeo.h.

Referenced by UpdateView().

1179 { fView = view; }

geo::PlaneGeo::fView

View_t fView

Does this plane measure U, V, or W?

Definition: PlaneGeo.h:1265

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

private

Whether the specified wire should have start and end swapped.

Definition at line 1205 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

                                                             {
     //
     // 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
     
   } // PlaneGeo::shouldFlipWire()

double geo::PlaneGeo::SinPhiZ ( ) const

inline

Sine of PhiZ()

Definition at line 184 of file PlaneGeo.h.

184 { return fSinPhiZ; }

geo::PlaneGeo::fSinPhiZ

double fSinPhiZ

Sine of .

Definition: PlaneGeo.h:1269

void geo::PlaneGeo::SortWires ( geo::GeoObjectSorter const & sorter )

Apply sorting to WireGeo objects.

Definition at line 550 of file PlaneGeo.cxx.

References fWire, util::SortByPointers(), and geo::GeoObjectSorter::SortWires().

   {
     // the sorter interface requires a vector of pointers;
     // sorting is faster, but some gymnastics is required:
     util::SortByPointers
       (fWire, [&sorter](auto& coll){ sorter.SortWires(coll); });
   }

double geo::PlaneGeo::ThetaZ ( ) const

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

Definition at line 728 of file PlaneGeo.cxx.

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

Referenced by tca::FilldEdx(), calo::Calorimetry::GetPitch(), and geo::GeometryCore::WireAngleToVertical().

728 { return FirstWire().ThetaZ(); }

geo::WireGeo::ThetaZ

double ThetaZ() const

Returns angle of wire with respect to z axis in the Y-Z plane in radians.

Definition: WireGeo.h:192

geo::PlaneGeo::FirstWire

const WireGeo & FirstWire() const

Return the first wire in the plane.

Definition: PlaneGeo.h:325

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

inline

Transform point from world frame to local plane frame.

Definition at line 1156 of file PlaneGeo.h.

1157 { 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:133

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

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

inline

Transform direction vector from world to local.

Definition at line 1168 of file PlaneGeo.h.

1169 { 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:133

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

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

inline

Transform point from local plane frame to world frame.

Definition at line 1132 of file PlaneGeo.h.

Referenced by BoundingBox(), and DetectGeometryDirections().

1133 { return fTrans.toWorldCoords(local); }

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformationGeo::toWorldCoords

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:103

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

inline

Transform direction vector from local to world.

Definition at line 1144 of file PlaneGeo.h.

1145 { return fTrans.toWorldCoords(local); }

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformationGeo::toWorldCoords

GlobalPoint_t toWorldCoords(LocalPoint_t const &local) const

Transforms a point from local frame to world frame.

Definition: LocalTransformationGeo.h:103

void geo::PlaneGeo::UpdateActiveArea ( )

private

Updates the internally used active area.

Definition at line 1162 of file PlaneGeo.cxx.

References fActiveArea.

Referenced by UpdateAfterSorting().

                                   {
     
     //
     // 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 = details::ActiveAreaCalculator(*this, 0.0001);
     
   } // PlaneGeo::UpdateActiveArea()

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

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

Definition at line 733 of file PlaneGeo.cxx.

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

Referenced by ThetaZ().

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

void geo::PlaneGeo::UpdateDecompWireOrigin ( )

private

Updates the position of the wire coordinate decomposition.

Definition at line 1152 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

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

void geo::PlaneGeo::UpdateIncreasingWireDir ( )

private

Updates the cached direction to increasing wires.

Definition at line 1082 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

                                          {
     
     //
     // 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 = geo::vect::toVector(refWire.Direction()); // we only rely on the axis
     
     
     // 2) get the axis perpendicular to it on the wire plane
     //    (arbitrary direction)
     auto wireCoordDir = GetNormalDirection<geo::Vector_t>().Cross(WireDir).Unit();
     
     // 3) where is the next wire?
     auto toNextWire
       = geo::vect::toVector(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(geo::vect::rounded01(wireCoordDir, 1e-4));
     
   } // PlaneGeo::UpdateIncreasingWireDir()

void geo::PlaneGeo::UpdateOrientation ( )

private

Updates plane orientation.

Definition at line 893 of file PlaneGeo.cxx.

References e, fOrientation, fWire, geo::kHorizontal, and geo::kVertical.

Referenced by UpdateAfterSorting().

                                    {
     
     //
     // 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<geo::Vector_t>();
     
     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";
     }
     
   } // PlaneGeo::UpdateOrientation()

void geo::PlaneGeo::UpdatePhiZ ( )

private

Updates the stored $\phi_{z}$ .

Definition at line 930 of file PlaneGeo.cxx.

References fCosPhiZ, fSinPhiZ, and GetIncreasingWireDirection().

Referenced by UpdateAfterSorting().

                             {
     TVector3 const& wire_coord_dir = GetIncreasingWireDirection();
   /*
     TVector3 const& normal = GetNormalDirection();
     TVector3 z(0., 0., 1.);
     
     // being defined in absolute terms as angle respect to z axis,
     // we take the z component as cosine, and all the rest as sine
     fCosPhiZ = wire_coord_dir.Dot(z);
     fSinPhiZ = wire_coord_dir.Cross(z).Dot(normal);
   */  
     fCosPhiZ = wire_coord_dir.Z();
     fSinPhiZ = wire_coord_dir.Y();
   } // PlaneGeo::UpdatePhiZ()

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

private

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

Definition at line 1041 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

                                                                  {
     
     //
     // 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
       = geo::vect::convertTo<TVector3>(TPCbox.Center()) - GetBoxCenter();
     
     // if they are pointing in opposite directions, flip the normal
     if (fNormal.Dot(towardCenter) < 0) fNormal = -fNormal;
     geo::vect::round01(fNormal, 1e-3);
     
   } // PlaneGeo::UpdatePlaneNormal()

void geo::PlaneGeo::UpdateView ( )

private

Updates the stored view.

Definition at line 945 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

   {
     /*
      * 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".
      * 
      */
     
     auto const& normalDir = GetNormalDirection<geo::Vector_t>();
     auto const& wireDir = GetWireDirection<geo::Vector_t>();
     
     // 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 = geo::vect::dot(wireDir, geo::Yaxis());
       double const ynw = geo::vect::mixedProduct
         (geo::Yaxis(), normalDir, wireDir);
       
       if (std::abs(yw) < 1.0e-4) { // wires orthogonal to y axis
         double const closeToX
           = std::abs(geo::vect::dot(normalDir, geo::Xaxis()));
         double const closeToZ
           = std::abs(geo::vect::dot(normalDir, geo::Zaxis()));
         SetView((closeToZ > closeToX)? geo::kX: geo::kY);
       }
       else if (std::abs(ynw) < 1.0e-4) { // wires parallel to y axis
         SetView(geo::kZ);
       }
       else if ((ynw * yw) < 0) SetView(geo::kU); // different sign => thetaY > 0
       else if ((ynw * yw) > 0) SetView(geo::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 = geo::vect::dot(wireDir, geo::Zaxis());
       // while GetNormalDirection() axis is on y, its direction is not fixed:
       double const znw = geo::vect::mixedProduct
         (geo::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(geo::kZ);
       }
       else if (std::abs(znw) < 1.0e-4) { // parallel to z, orthogonal to y...
         // this is equivalent to thetaZ = 0
         SetView(geo::kX);
       }
       else if ((znw * zw) < 0) SetView(geo::kU); // different sign => thetaZ > 0
       else if ((znw * zw) > 0) SetView(geo::kV); // same sign => thetaZ < 0
       else assert(false); // logic error?!
       
     } // if drift direction... else
     
   } // UpdateView()

void geo::PlaneGeo::UpdateWidthDepthDir ( )

private

Updates the cached depth and width direction.

Definition at line 1062 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().

                                      {
     
     //
     // 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
         (geo::vect::rounded01(-fDecompFrame.SecondaryDir(), 1e-4));
     }
     
   } // PlaneGeo::UpdateWidthDepthDir()

void geo::PlaneGeo::UpdateWireDir ( )

private

Updates the cached direction to wire.

Definition at line 1116 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

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

void geo::PlaneGeo::UpdateWirePitch ( )

private

Updates the stored wire pitch.

Definition at line 925 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

                                  {
     fWirePitch = geo::WireGeo::WirePitch(Wire(0), Wire(1));
   } // PlaneGeo::UpdateWirePitch()

void geo::PlaneGeo::UpdateWirePitchSlow ( )

private

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

Definition at line 1130 of file PlaneGeo.cxx.

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

Referenced by PlaneGeo().

                                      {
     
     // 
     // 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 (which UpdateWirePitch() does).
     // 
     auto firstWire = fWire.cbegin(), wire = firstWire, wend = fWire.cend();
     fWirePitch = geo::WireGeo::WirePitch(*firstWire, *(++wire));
     
     while (++wire != wend) {
       auto wirePitch = geo::WireGeo::WirePitch(*firstWire, *wire);
       if (wirePitch < 1e-4) continue; // it's 0!
       if (wirePitch < fWirePitch) fWirePitch = wirePitch;
     } // while
     
   } // PlaneGeo::UpdateWirePitchSlow()

void geo::PlaneGeo::UpdateWirePlaneCenter ( )

private

Updates the stored wire plane center.

Definition at line 1178 of file PlaneGeo.cxx.

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

Referenced by UpdateAfterSorting().

                                        {
     
     //
     // 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<geo::Point_t>();
     
     DriftPoint(fCenter, DistanceFromPlane(fCenter));
     
     fDecompFrame.SetOrigin(fCenter); // equivalent to GetCenter() now
     
   } // PlaneGeo::UpdateWirePlaneCenter()

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

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 802 of file PlaneGeo.h.

803 { return Projection(v); }

geo::PlaneGeo::Projection

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

Returns the projection of the specified point on the plane.

Definition: PlaneGeo.h:779

WireCoordProjection_t geo::PlaneGeo::VectorProjection ( TVector3 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 804 of file PlaneGeo.h.

References geo::vect::toVector().

805 { return VectorProjection(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:1286

geo::PlaneGeo::VectorProjection

WireCoordProjection_t VectorProjection(geo::Vector_t const &v) const

Returns the projection of the specified vector on the plane.

Definition: PlaneGeo.h:802

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

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 917 of file PlaneGeo.h.

Referenced by geo::details::ActiveAreaCalculator::adjustCorners(), and geo::TPCGeo::Projection().

918 { return fDecompFrame.ProjectVectorOnPlane(v); }

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

geo::Decomposer::ProjectVectorOnPlane

Projection_t ProjectVectorOnPlane(Vector_t const &v) const

Returns the projection of the specified vector on the plane.

Definition: Decomposer.h:549

WidthDepthProjection_t geo::PlaneGeo::VectorWidthDepthProjection ( TVector3 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 920 of file PlaneGeo.h.

References geo::vect::toVector().

921 { return VectorWidthDepthProjection(geo::vect::toVector(v)); }

geo::PlaneGeo::VectorWidthDepthProjection

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

Returns the projection of the specified vector on the plane.

Definition: PlaneGeo.h:917

geo::vect::toVector

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

Convert the specified vector into a geo::Vector_t.

Definition: geo_vectors_utils.h:1286

View_t geo::PlaneGeo::View ( ) const

inline

Which coordinate does this plane measure.

Definition at line 171 of file PlaneGeo.h.

Referenced by cluster::ClusterAna::analyze(), pfpf::PFPAna::analyze(), cluster::DBclusterAna::analyze(), cluster::ClusterMergeHelper::AppendResult(), util::GeometryUtilities::CalculatePitch(), util::GeometryUtilities::CalculatePitchPolar(), util::DetectorPropertiesServiceArgoNeuT::CalculateXTicksParams(), detinfo::DetectorPropertiesStandard::CalculateXTicksParams(), evd::RecoBaseDrawer::Cluster2D(), hit::DisambigCheater::DisambigCheater(), evd::RecoBaseDrawer::DrawTrackVertexAssns2D(), evd::RecoBaseDrawer::EndPoint2D(), evd::RecoBaseDrawer::Event2D(), filter::MuonFilter::filter(), util::GeometryUtilities::Get2DangleFrom3D(), corner::CornerFinderAlg::get_feature_points_fast(), trkf::BezierTrack::GetTrackPitch(), lar_pandora::LArPandoraGeometry::LoadGeometry(), shower::EMShowerAlg::MakeShower(), util::GeometryUtilities::PitchInView(), cluster::SimpleClusterMerger::produce(), cluster::FuzzyClusterMerger::produce(), cluster::SmallClusterFinder::produce(), calo::Calorimetry::produce(), evd::GraphCluster::produce(), evd::RecoBaseDrawer::Prong2D(), trkf::SpacePointAlg::update(), geo::GeometryCore::View(), geo::TPCGeo::Views(), and geo::GeometryCore::WireAngleToVertical().

171 { return fView; }

geo::PlaneGeo::fView

View_t fView

Does this plane measure U, V, or W?

Definition: PlaneGeo.h:1265

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

static

Returns the name of the specified view.

Definition at line 765 of file PlaneGeo.cxx.

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

Referenced by trkf::SeedFinderAlgorithm::GetCenterAndDirection(), and geo::GeometryCore::WireAngleToVertical().

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

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 227 of file PlaneGeo.h.

227 { return fFrameSize.Width(); }

geo::PlaneGeo::fFrameSize

RectSpecs fFrameSize

Definition: PlaneGeo.h:1281

geo::PlaneGeo::RectSpecs::Width

double Width() const

Definition: PlaneGeo.h:1259

template<typename Vector = DefaultVector_t>

Vector geo::PlaneGeo::WidthDir ( ) const

inline

Return the direction of plane width.

Template Parameters

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

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 207 of file PlaneGeo.h.

Referenced by MovePointOverPlane(), geo::TPCGeo::RefWidthDir(), and UpdateWidthDepthDir().

207 { return geo::vect::convertTo<Vector>(fDecompFrame.MainDir()); }

geo::PlaneGeo::fDecompFrame

WidthDepthDecomposer_t fDecompFrame

Definition: PlaneGeo.h:1280

geo::Decomposer::MainDir

Vector_t const & MainDir() const

Returns the plane main axis direction.

Definition: Decomposer.h:463

geo::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 506 of file PlaneGeo.cxx.

References WirePtr().

Referenced by hit::MagDriftAna::analyze(), lar_pandora::LArPandoraInput::CreatePandoraHits2D(), lar_pandora::LArPandoraInput::CreatePandoraReadoutGaps(), hit::DisambigCheater::DisambigCheater(), trkf::Track3DKalmanSPS::dQdxCalc(), evd::RecoBaseDrawer::DrawTrack2D(), GetNormalAxis(), lar_pandora::PFParticleHitDumper::GetUVW(), geo::ChannelMapStandardAlg::Initialize(), trkf::SpacePointAlg::makeSpacePoints(), NearestWire(), geo::GeometryCore::Print(), trkf::SpacePts::produce(), trkf::Track3Dreco::produce(), vertex::VertexFinder2D::produce(), util::GeometryUtilities::Reconfigure(), trkf::SpacePointAlg::update(), UpdateIncreasingWireDir(), and UpdateWirePitch().

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

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 294 of file PlaneGeo.h.

References geo::WireID::Wire.

295 { return Wire(wireid.Wire); }

geo::PlaneGeo::Wire

WireGeo const & Wire(unsigned int iwire) const

Definition: PlaneGeo.cxx:506

template<typename Point = DefaultPoint_t>

double geo::PlaneGeo::WireCoordinate ( Point 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 725 of file PlaneGeo.h.

Referenced by lar_cluster3d::StandardHit3DBuilder::NearestWireID(), NearestWireID(), and geo::GeometryCore::WireCoordinate().

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

geo::PlaneGeo::PlaneCoordinate

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

Returns the coordinate of the point on the plane.

Definition: PlaneGeo.h:704

geo::PlaneGeo::WirePitch

double WirePitch() const

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

Definition: PlaneGeo.h:367

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 560 of file PlaneGeo.cxx.

References GetIncreasingWireDirection().

                                             {
     return GetIncreasingWireDirection().Z() > 0.;
   } // PlaneGeo::WireIDincreasesWithZ()

double geo::PlaneGeo::WirePitch ( ) const

inline

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

Definition at line 367 of file PlaneGeo.h.

Referenced by geo::details::ActiveAreaCalculator::adjustCorners(), pma::CmToWireDrift(), pma::ProjectionMatchingAlg::GetCloseHits(), geo::GeometryCore::ThirdPlane_dTdW(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc_test(), pma::WireDriftToCm(), geo::TPCGeo::WirePitch(), and geo::GeometryCore::WirePitch().

367 { return fWirePitch; }

geo::PlaneGeo::fWirePitch

double fWirePitch

Pitch of wires in this plane.

Definition: PlaneGeo.h:1268

WireGeo const* 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 305 of file PlaneGeo.h.

Referenced by Wire(), and geo::GeometryCore::WirePtr().

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

geo::PlaneGeo::fWire

WireCollection_t fWire

List of wires in this plane.

Definition: PlaneGeo.h:1267

geo::PlaneGeo::HasWire

bool HasWire(unsigned int iwire) const

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

Definition: PlaneGeo.h:260

WireGeo const* geo::PlaneGeo::WirePtr ( 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 317 of file PlaneGeo.h.

References geo::WireID::Wire.

318 { return WirePtr(wireid.Wire); }

geo::PlaneGeo::WirePtr

WireGeo const * WirePtr(unsigned int iwire) const

Returns the wire number iwire from this plane.

Definition: PlaneGeo.h:305

void geo::PlaneGeo::WorldToLocal	(	const double *	world,
		double *	plane
	)		const

inline

Transform point from world frame to local plane frame.

Definition at line 1148 of file PlaneGeo.h.

1149 { fTrans.WorldToLocal(world, plane); }

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformation::WorldToLocal

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

Transforms a point from world frame to local frame.

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

inline

Transform point from world frame to local plane frame.

Definition at line 1152 of file PlaneGeo.h.

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

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformation::WorldToLocal

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

Transforms a point from world frame to local frame.

void geo::PlaneGeo::WorldToLocalVect	(	const double *	world,
		double *	plane
	)		const

inline

Transform direction vector from world to local.

Definition at line 1160 of file PlaneGeo.h.

1161 { fTrans.WorldToLocalVect(world, plane); }

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformation::WorldToLocalVect

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

Transforms a vector from world frame to local frame.

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

inline

Transform direction vector from world to local.

Definition at line 1164 of file PlaneGeo.h.

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

geo::PlaneGeo::fTrans

LocalTransformation_t fTrans

Plane to world transform.

Definition: PlaneGeo.h:1263

geo::LocalTransformation::WorldToLocalVect

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

Transforms a vector from world frame to local frame.

Friends And Related Function Documentation

friend struct details::ActiveAreaCalculator

friend

Definition at line 1289 of file PlaneGeo.h.

Member Data Documentation

Rect geo::PlaneGeo::fActiveArea

private

Area covered by wires in frame base.

Definition at line 1283 of file PlaneGeo.h.

Referenced by DeltaFromActivePlane(), and UpdateActiveArea().

geo::Point_t geo::PlaneGeo::fCenter

private

Center of the plane, lying on the wire plane.

Definition at line 1285 of file PlaneGeo.h.

Referenced by UpdateWirePlaneCenter().

double geo::PlaneGeo::fCosPhiZ

private

Cosine of $\phi_{z}$ .

Definition at line 1270 of file PlaneGeo.h.

Referenced by UpdatePhiZ().

WidthDepthDecomposer_t geo::PlaneGeo::fDecompFrame

private

Decomposition on frame coordinates; the main direction is a "width", the secondary one is just orthogonal to it ("depth"). Normal can differ in sign from the plane one.

Definition at line 1280 of file PlaneGeo.h.

Referenced by DetectGeometryDirections(), UpdateWidthDepthDir(), and UpdateWirePlaneCenter().

WireDecomposer_t geo::PlaneGeo::fDecompWire

private

Decomposition on wire coordinates; the main direction is along the wire, the secondary one is the one measured by the wire, the normal matches the plane's normal.

Definition at line 1276 of file PlaneGeo.h.

Referenced by UpdateDecompWireOrigin(), UpdateIncreasingWireDir(), and UpdateWireDir().

RectSpecs geo::PlaneGeo::fFrameSize

private

Size of the frame of the plane.

Definition at line 1281 of file PlaneGeo.h.

Referenced by DeltaFromPlane(), DetectGeometryDirections(), and MoveProjectionToPlane().

geo::PlaneID geo::PlaneGeo::fID

private

ID of this plane.

Definition at line 1287 of file PlaneGeo.h.

Referenced by UpdateAfterSorting().

geo::Vector_t geo::PlaneGeo::fNormal

private

Normal to the plane, inward in TPC.

Definition at line 1272 of file PlaneGeo.h.

Referenced by UpdatePlaneNormal().

Orient_t geo::PlaneGeo::fOrientation

private

Is the plane vertical or horizontal?

Definition at line 1266 of file PlaneGeo.h.

Referenced by UpdateOrientation().

double geo::PlaneGeo::fSinPhiZ

private

Sine of $\phi_{z}$ .

Definition at line 1269 of file PlaneGeo.h.

Referenced by UpdatePhiZ().

LocalTransformation_t geo::PlaneGeo::fTrans

private

Plane to world transform.

Definition at line 1263 of file PlaneGeo.h.

View_t geo::PlaneGeo::fView

private

Does this plane measure U, V, or W?

Definition at line 1265 of file PlaneGeo.h.

TGeoVolume const* geo::PlaneGeo::fVolume

private

Plane volume description.

Definition at line 1264 of file PlaneGeo.h.

Referenced by BoundingBox(), DetectGeometryDirections(), and PlaneGeo().

WireCollection_t geo::PlaneGeo::fWire

private

List of wires in this plane.

Definition at line 1267 of file PlaneGeo.h.

Referenced by MakeWire(), SortWires(), UpdateAfterSorting(), UpdateOrientation(), and UpdateWirePitchSlow().

double geo::PlaneGeo::fWirePitch

private

Pitch of wires in this plane.

Definition at line 1268 of file PlaneGeo.h.

Referenced by UpdateWirePitch(), and UpdateWirePitchSlow().

constexpr unsigned int geo::PlaneGeo::MaxVerbosity = 6

static

Maximum value for print verbosity.

Definition at line 645 of file PlaneGeo.h.

Referenced by geo::GeometryCore::Print().

The documentation for this class was generated from the following files:

larcorealg/v1_24_01/source/larcorealg/Geometry/PlaneGeo.h
larcorealg/v1_24_01/source/larcorealg/Geometry/PlaneGeo.cxx

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Verbosity levels

Friends And Related Function Documentation

Member Data Documentation