geo Namespace Reference

LArSoft geometry interface. More...

Namespaces
	CRU
	details
	dune
	fhicl
	FHiCL objects representing geometry classes as configuration parameters.
	iterators
	part
	Partition-related utilities.
	vect
	Utilities to manipulate geometry vectors.The utilities include generic vector interface facilities allowing to use different vector types via templates.

Classes
class	AffinePlaneBase
class	AuxDetChannelMapAlg
class	AuxDetExptGeoHelperInterface
	Interface to a service with detector-specific geometry knowledge. More...
class	AuxDetGeo
class	AuxDetGeometry
	The geometry of one entire detector, as served by art. More...
class	AuxDetGeometryCore
	Description of geometry of one set of auxiliary detectors. More...
struct	AuxDetGeometryData_t
class	AuxDetGeoObjectSorter
class	AuxDetSensitiveGeo
class	BoxBoundedGeo
	A base class aware of world box coordinatesAn object describing a simple shape can inherit from this one to gain access to a common boundary checking interface. More...
class	ChannelMap35Alg
class	ChannelMap35OptAlg
class	ChannelMapAlg
	Interface for a class providing readout channel mapping to geometry. More...
class	ChannelMapAPAAlg
class	ChannelMapCRMAlg
class	ChannelMapCRUAlg
class	ChannelMapSetupTool
	Interface for a tool creating a channel mapping object. More...
class	ChannelMapStandardAlg
class	ChannelMapStandardTestAlg
class	ColdBoxChannelMapAlg
struct	CollectNodesByName
struct	CollectPathsByName
class	CryostatGeo
	Geometry information for a single cryostat. More...
struct	CryostatID
	The data type to uniquely identify a cryostat. More...
struct	DecomposedVector
class	Decomposer
	Class with methods to decompose and compose back vectors. More...
class	DriftPartitions
	Set of drift volumes. More...
class	DumpChannelMap
	Prints on screen the current channel-wire and optical detector maps. More...
class	DumpGeometry
	Describes on screen the current geometry. More...
class	DuneApaChannelMapAlg
struct	ElementLevel
class	ExptGeoHelperInterface
	Interface to a service with detector-specific geometry knowledge. More...
class	GeoIDdataContainer
	Container with one element per geometry TPC. More...
class	GeoIDmapper
	Class managing the mapping between geometry/readout ID and flat index. More...
class	Geometry
	The geometry of one entire detector, as served by art. More...
class	GeometryBuilder
	Manages the extraction of LArSoft geometry information from ROOT. More...
class	GeometryBuilderStandard
	Extracts of LArSoft geometry information from ROOT. More...
class	GeometryBuilderWireless
	Geometry builder which ignores wires on wire planes. More...
class	GeometryConfigurationWriter
	Writes geometry configuration information into art runs. More...
class	GeometryCore
	Description of geometry of one entire detector. More...
struct	GeometryData_t
	Data in the geometry description. More...
class	GeometryGeoIDTestAlg
class	GeometryInfoCheck
class	GeometryIteratorLoopTest
	Performs tests on the geometry as seen by Geometry service. More...
class	GeometryIteratorLoopTestAlg
class	GeometryIteratorTestAlg
class	GeometryTest
	Performs tests on the geometry as seen by Geometry service. More...
class	GeometryTestAlg
	Performs tests on the geometry as seen by Geometry service. More...
class	GeoNodePath
	Representation of a node and its ancestry. More...
class	GeoObjectSorter
class	GeoObjectSorter35
class	GeoObjectSorterAPA
class	GeoObjectSorterCRM
class	GeoObjectSorterCRU
class	GeoObjectSorterStandard
struct	IntersectionPointAndOffsets
	Data structure for return values of LineClosestPointAndOffsets(). More...
class	InvalidWireError
	Exception thrown on invalid wire number. More...
class	InvalidWireIDError
	Exception thrown on invalid wire number (e.g. NearestWireID()) More...
class	IteratorBox
class	LegacyGeometryInfoWriter
class	LocalIteratorBox
class	LocalTransformation
	Class to transform between world and local coordinates. More...
class	LocalTransformationGeo
	Class to transform between world and local coordinates. More...
class	MuonCounter35Alg
struct	NodeNameMatcherClass
class	OpDetGeo
struct	OpDetID
	The data type to uniquely identify a optical detector. More...
struct	OpticalLocalCoordinateSystemTag
	The tag defining the optical detector local reference frame. More...
class	PlaneBase
	A base for a plane in space. More...
class	PlaneDataContainer
	Container with one element per geometry wire plane. More...
class	PlaneDecomposer
	Class with methods for projection of vectors on a plane. More...
class	PlaneGeo
	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...
struct	PlaneID
	The data type to uniquely identify a Plane. More...
class	PlaneIDmapper
	Mapping for sensitive plane identifiers. More...
class	ProtoDUNEChannelMapAlg
class	ProtoDUNEChannelMapAlgv7
class	ProtoDUNEChannelMapAlgv8
class	ROOTGeometryNavigator
	Executes an operation on all the nodes of the ROOT geometry. More...
class	ROOTGeoNodeForwardIterator
	Iterator to navigate through all the nodes. More...
struct	sortWire35
class	StandardGeometryHelper
	Simple implementation of channel mapping. More...
class	TPCDataContainer
	Container with one element per geometry TPC. More...
class	TPCGeo
	Geometry information for a single TPC. More...
struct	TPCID
	The data type to uniquely identify a TPC. More...
class	TPCIDmapper
	Mapping for TPC identifiers. More...
class	WireGeo
	Geometry description of a TPC wireThe wire is a single straight segment on a wire plane. Different wires may be connected to the same readout channel. That is of no relevance for the geometry description. More...
struct	WireID
struct	WireIDIntersection

Typedefs
using	GeoNodeIterator_t = std::vector< TGeoNode const * >::const_iterator
using	WirePtr = WireGeo const *
using	TransformationMatrix = ROOT::Math::Transform3D
	Type of transformation matrix used in geometry. More...
Generic vector types.
template<typename T , typename C = ROOT::Math::GlobalCoordinateSystemTag>
using	GenVector3DBase_t = ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< T >, C >
template<typename T , typename C = ROOT::Math::GlobalCoordinateSystemTag>
using	GenPoint3DBase_t = ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< T >, C >
template<typename C >
using	Vector3DBase_t = GenVector3DBase_t< double, C >
template<typename C >
using	Point3DBase_t = GenPoint3DBase_t< double, C >
	Type of 3D point with representation in double precision. More...
using	cryostat_id_iterator = details::cryostat_id_iterator_base< geo::CryostatID >
	Forward iterator browsing all cryostats in the detector. More...
using	cryostat_iterator = details::geometry_element_iterator< cryostat_id_iterator >
	Forward iterator browsing all cryostats in the detector. More...
using	TPC_id_iterator = details::TPC_id_iterator_base< geo::TPCID >
	Forward iterator browsing all TPCs in the detector. More...
using	TPC_iterator = details::geometry_element_iterator< TPC_id_iterator >
	Forward iterator browsing all TPCs in the detector. More...
using	plane_id_iterator = details::plane_id_iterator_base< geo::PlaneID >
	Forward iterator browsing all planes in the detector. More...
using	plane_iterator = details::geometry_element_iterator< plane_id_iterator >
	Forward iterator browsing all planes in the detector. More...
using	wire_id_iterator = details::wire_id_iterator_base< geo::WireID >
	Forward iterator browsing all wires in the detector. More...
using	wire_iterator = details::geometry_element_iterator< wire_id_iterator >
	Forward iterator browsing all wires in the detector. More...
using	TPCset_id_iterator = details::TPCset_id_iterator_base< readout::TPCsetID >
	Forward iterator browsing all TPC sets in the detector. More...
using	ROP_id_iterator = details::ROP_id_iterator_base< readout::ROPID >
	Forward iterator browsing all readout planes in the detector. More...
Optical detector vector types.
Special tags for a generic "optical detector local coordinate system" are defined here, together with data types using them. While the world coordinate system makes sense to be defined in this way, a local system depends by definition by the object it is anchored to: while two world coordinate vectors are always compatible, two local coordinate vectors are compatible only if they belong to the same local object. The purpose of these definitions is to declare the incompatibility between world coordinate vectors and the ones local to optical detectors, without attempting to claim that two of the latter are necessarily compatible.
template<typename T >
using	OpticalVector3DBase_t = GenVector3DBase_t< T, OpticalLocalCoordinateSystemTag >
template<typename T >
using	OpticalPoint3DBase_t = GenPoint3DBase_t< T, OpticalLocalCoordinateSystemTag >
using	OpticalVector_t = OpticalVector3DBase_t< double >
using	OpticalPoint_t = OpticalPoint3DBase_t< double >
	Type of optical 3D point with representation in double precision. More...

Functions
static bool	sortAuxDet35 (const AuxDetGeo &ad1, const AuxDetGeo &ad2)
static bool	sortAuxDetSensitive35 (const AuxDetSensitiveGeo &ad1, const AuxDetSensitiveGeo &ad2)
static bool	sortCryo35 (const CryostatGeo &c1, const CryostatGeo &c2)
static bool	sortTPC35 (const TPCGeo &t1, const TPCGeo &t2)
static bool	sortPlane35 (const PlaneGeo &p1, const PlaneGeo &p2)
static bool	sortAuxDetAPA (const AuxDetGeo &ad1, const AuxDetGeo &ad2)
static bool	sortAuxDetSensitiveAPA (const AuxDetSensitiveGeo &ad1, const AuxDetSensitiveGeo &ad2)
static bool	sortCryoAPA (const CryostatGeo &c1, const CryostatGeo &c2)
static bool	sortTPCAPA (const TPCGeo &t1, const TPCGeo &t2)
static bool	sortPlaneAPA (const PlaneGeo &p1, const PlaneGeo &p2)
bool	sortWireAPA (WireGeo &w1, WireGeo &w2)
static bool	sortAuxDetCRM (const AuxDetGeo &ad1, const AuxDetGeo &ad2)
static bool	sortAuxDetSensitiveCRM (const AuxDetSensitiveGeo &ad1, const AuxDetSensitiveGeo &ad2)
static bool	sortCryoCRM (const CryostatGeo &c1, const CryostatGeo &c2)
static bool	sortTPCCRM (const TPCGeo &t1, const TPCGeo &t2)
static bool	sortPlaneCRM (const PlaneGeo &p1, const PlaneGeo &p2)
bool	sortWireCRM (WireGeo const &w1, WireGeo const &w2)
bool	sortorderOpDet (const OpDetGeo &t1, const OpDetGeo &t2)
void	ProjectToBoxEdge (const double xyz[], const double dxyz[], double xlo, double xhi, double ylo, double yhi, double zlo, double zhi, double xyzout[])
double	ClosestApproach (const double point[], const double intercept[], const double slopes[], double closest[])
bool	CrossesBoundary (double x0[], double gradient[], double x_lo, double x_hi, double y_lo, double y_hi, double z_lo, double z_hi, double point[])
template<>
geo::TPCID	GeometryCore::GetBeginID< geo::TPCID, geo::CryostatID > (geo::CryostatID const &id) const
template<>
geo::TPCID	GeometryCore::GetEndID< geo::TPCID, geo::CryostatID > (geo::CryostatID const &id) const
template<>
geo::PlaneID	GeometryCore::GetBeginID< geo::PlaneID, geo::CryostatID > (geo::CryostatID const &id) const
template<>
geo::PlaneID	GeometryCore::GetEndID< geo::PlaneID, geo::CryostatID > (geo::CryostatID const &id) const
static bool	sortorderOpDets (const OpDetGeo &t1, const OpDetGeo &t2)
static bool	sortAuxDetStandard (const AuxDetGeo &ad1, const AuxDetGeo &ad2)
static bool	sortAuxDetSensitiveStandard (const AuxDetSensitiveGeo &ad1, const AuxDetSensitiveGeo &ad2)
static bool	sortCryoStandard (const CryostatGeo &c1, const CryostatGeo &c2)
static bool	sortTPCStandard (const TPCGeo &t1, const TPCGeo &t2)
static bool	sortPlaneStandard (const PlaneGeo &p1, const PlaneGeo &p2)
static bool	sortWireStandard (WireGeo const &w1, WireGeo const &w2)
template<typename Point , typename Vector >
IntersectionPointAndOffsets< Point >	LineClosestPointAndOffsets (Point const &startA, Vector const &dirA, Point const &startB, Vector const &dirB)
	Returns the point of a line that is closest to a second line. More...
template<typename Point , typename Vector >
Point	LineClosestPoint (Point const &startA, Vector const &dirA, Point const &startB, Vector const &dirB)
	Returns the point of a line that is closest to a second line. More...
template<typename Point , typename UnitVector >
IntersectionPointAndOffsets< Point >	LineClosestPointAndOffsetsWithUnitVectors (Point const &startA, UnitVector const &dirA, Point const &startB, UnitVector const &dirB)
	Returns the point of a line that is closest to a second line. More...
template<typename Point , typename UnitVector >
Point	LineClosestPointWithUnitVectors (Point const &startA, UnitVector const &dirA, Point const &startB, UnitVector const &dirB)
	Returns the point of a line that is closest to a second line. More...
template<typename StoredMatrix , typename ITER >
static StoredMatrix	transformationFromPath (ITER begin, ITER end)
	Builds a matrix to go from local to world coordinates in one step. More...
template<typename StoredMatrix >
static StoredMatrix	transformationFromPath (std::vector< TGeoNode const * > const &path, size_t depth)
	Builds a matrix to go from local to world coordinates in one step. More...
template<typename Dest , typename Src >
decltype(auto)	convertTransformationMatrix (Src &&trans)
	Converts a transformation matrix into Dest format. More...
template<typename Trans >
decltype(auto)	makeTransformationMatrix (Trans &&trans)
	Converts a transformation matrix into a geo::TransformationMatrix. More...
geo::Point_t	WiresIntersection (geo::WireGeo const &wireA, geo::WireGeo const &wireB)
	Returns the point of wireA that is closest to wireB. More...
geo::IntersectionPointAndOffsets< geo::Point_t >	WiresIntersectionAndOffsets (geo::WireGeo const &wireA, geo::WireGeo const &wireB)
	Returns the point of wireA that is closest to wireB. More...
std::string	SignalTypeName (geo::SigType_t sigType)
	Returns the name of the specified signal type. More...
DriftPartitions	buildDriftVolumes (geo::CryostatGeo const &cryo)
	Creates a DriftPartitions object from the TPCs in a cryostat. More...
Geometry element IDs
std::ostream &	operator<< (std::ostream &out, CryostatID const &cid)
	Generic output of CryostatID to stream. More...
std::ostream &	operator<< (std::ostream &out, OpDetID const &oid)
	Generic output of OpDetID to stream. More...
std::ostream &	operator<< (std::ostream &out, TPCID const &tid)
	Generic output of TPCID to stream. More...
std::ostream &	operator<< (std::ostream &out, PlaneID const &pid)
	Generic output of PlaneID to stream. More...
std::ostream &	operator<< (std::ostream &out, WireID const &wid)
	Generic output of WireID to stream. More...
ID comparison operators
The result of comparison with invalid IDs is undefined.
constexpr bool	operator== (CryostatID const &a, CryostatID const &b)
	Comparison: the IDs point to the same cryostat (validity is ignored) More...
constexpr bool	operator!= (CryostatID const &a, CryostatID const &b)
	Comparison: the IDs point to different cryostats (validity is ignored) More...
constexpr bool	operator< (CryostatID const &a, CryostatID const &b)
	Order cryostats with increasing ID. More...
constexpr bool	operator== (OpDetID const &a, OpDetID const &b)
	Comparison: the IDs point to same optical detector (validity is ignored) More...
constexpr bool	operator!= (OpDetID const &a, OpDetID const &b)
	Comparison: IDs point to different optical detectors (validity is ignored) More...
constexpr bool	operator< (OpDetID const &a, OpDetID const &b)
	Order OpDetID in increasing Cryo, then OpDet. More...
constexpr bool	operator== (TPCID const &a, TPCID const &b)
	Comparison: the IDs point to the same TPC (validity is ignored) More...
constexpr bool	operator!= (TPCID const &a, TPCID const &b)
	Comparison: the IDs point to different TPCs (validity is ignored) More...
constexpr bool	operator< (TPCID const &a, TPCID const &b)
	Order TPCID in increasing Cryo, then TPC. More...
constexpr bool	operator== (PlaneID const &a, PlaneID const &b)
	Comparison: the IDs point to the same plane (validity is ignored) More...
constexpr bool	operator!= (PlaneID const &a, PlaneID const &b)
	Comparison: the IDs point to different planes (validity is ignored) More...
constexpr bool	operator< (PlaneID const &a, PlaneID const &b)
	Order PlaneID in increasing TPC, then plane. More...
constexpr bool	operator== (WireID const &a, WireID const &b)
	Comparison: the IDs point to the same wire (validity is ignored) More...
constexpr bool	operator!= (WireID const &a, WireID const &b)
	Comparison: the IDs point to different wires (validity is ignored) More...
constexpr bool	operator< (WireID const &a, WireID const &b)

Vector types for the standard LArSoft geometry.
LArSoft geometry provides two main types of vectors in 3D space: geo::Point_t to describe an absolute position in global coordinates geo::Vector_t to describe a displacement or direction (or momentum!) Both vectors are supposed to represent: centimeters in double precision when used on the real geometry space in the global coordinate system, which is represented by the tag geo::GlobalCoords. These types constitute the basic objects the geometry works with. All interfaces should support them. Note As this requires some transition, please report any interface missing support for these types by opening a "necessary maintenance" request in the LArSoft issue tracker at https://cdcvs.fnal.gov/redmine/projects/larsoft/issues . Even if there are plenty. The same type of vectors, but in a different coordinate system representation, can be obtained by using geo::Point3DBase_t template: using LocalPoint_t = geo::Point3DBase_t<LocalCoordinateTag>; (geo::Vector3DBase_t is also available). If a single precision vector is desired, the most general geo::GenPoint3DBase_t and geo::GenVector3DBase_t are also available: using PointF_t = geo::GenPoint3DBase_t<float>; using VectorF_t = geo::GenVector3DBase_t<float>;
using	Length_t = double
	Type used for coordinates and distances. They are measured in centimeters. More...
using	GlobalCoords = ROOT::Math::GlobalCoordinateSystemTag
	Tag for vectors in the global coordinate system. More...
using	Vector_t = ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag >
	Type for representation of momenta in 3D space. More...
using	Point_t = ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag >
	Type for representation of position in physical 3D space. More...
template<typename CoordSystemTag >
using	VectorIn_t = Vector3DBase_t< CoordSystemTag >
	Type for representation of momenta in 3D space. More...
template<typename CoordSystemTag >
using	PointIn_t = Point3DBase_t< CoordSystemTag >
	Type for representation of positions in 3D space. More...
using	Rotation_t = ROOT::Math::Rotation3D
	Type for representation of space rotations. More...
template<typename Vector = Vector_t>
constexpr Vector	Xaxis ()
	Returns a x axis vector of the specified type. More...
template<typename Vector = Vector_t>
constexpr Vector	Yaxis ()
	Returns a y axis vector of the specified type. More...
template<typename Vector = Vector_t>
constexpr Vector	Zaxis ()
	Returns a z axis vector of the specified type. More...
template<typename Point = Point_t>
constexpr Point	origin ()
	Returns a origin position with a point of the specified type. More...

Geometry enumerators
enum	coordinates { kXCoord, kYCoord, kZCoord }
enum	_plane_proj {   kU, kV, kW, kZ =kW,   kY, kX, k3D, kUnknown }
	Enumerate the possible plane projections. More...
enum	_plane_orient { kHorizontal, kVertical }
enum	_plane_sigtype { kInduction, kCollection, kMysteryType }
enum	driftdir {   kUnknownDrift, kPos, kNeg, kPosX = kPos,   kNegX = kNeg }
	Drift direction: positive or negative. More...
typedef enum geo::coordinates	Coord_t
typedef enum geo::_plane_proj	View_t
	Enumerate the possible plane projections. More...
typedef enum geo::_plane_orient	Orient_t
typedef enum geo::_plane_sigtype	SigType_t
typedef enum geo::driftdir	DriftDirection_t
	Drift direction: positive or negative. More...

Detailed Description

LArSoft geometry interface.

Detector geometry definition and interface.

ROOT libraries.

Namespace collecting geometry-related classes utilities.

Writes a sumdata::RunData record into the run(s).

Verifies that the geometry check information is available.

See also

geo::GeometryCore

The geo namespace includes all LArSoft data types, classes and functions related to detector geometry.

For more guidance, dee the LArSoft geometry module.

Configuration parameters

A copy of the same data product is put into each of the runs on opening.

Configuration parameters

• Name (string, mandatory): name of the detector to be stored in the sumdata::RunData data product

TrackLineFitAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm for fitting a 3D line given a number of points in 3 wire planes

TrackTrajectoryAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm fitting a 3D trajectory through a set of hit pairs

Typedef Documentation

typedef enum geo::coordinates geo::Coord_t

typedef enum geo::driftdir geo::DriftDirection_t

Drift direction: positive or negative.

Do not use this type to distinguish different drift axes: e.g., negative x drift and negative z drift are both by kNeg.

template<typename T , typename C = ROOT::Math::GlobalCoordinateSystemTag>

using geo::GenPoint3DBase_t = typedef ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<T>, C>

Type of 3D point.

Template Parameters

T	data type for coordinate representation
C	coordinate system tag (default: global coordinates)

Definition at line 82 of file geo_vectors.h.

template<typename T , typename C = ROOT::Math::GlobalCoordinateSystemTag>

using geo::GenVector3DBase_t = typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<T>, C>

Type of 3D displacement vector.

Template Parameters

T	data type for coordinate representation
C	coordinate system tag (default: global coordinates)

Definition at line 75 of file geo_vectors.h.

using geo::GeoNodeIterator_t = typedef std::vector<TGeoNode const*>::const_iterator

Definition at line 36 of file LocalTransformation.h.

typedef ROOT::Math::GlobalCoordinateSystemTag geo::GlobalCoords

Tag for vectors in the global coordinate system.

A vector tagged as "global" is expected to be represented in the global (or "world") coordinate system.

That system is the one the detector geometry is described in, and it is defined by the GDML detector description. The linear coordinates are described in centimeters.

Definition at line 150 of file geo_vectors.h.

typedef double geo::Length_t

Type used for coordinates and distances. They are measured in centimeters.

Definition at line 137 of file geo_vectors.h.

template<typename T >

using geo::OpticalPoint3DBase_t = typedef GenPoint3DBase_t<T, OpticalLocalCoordinateSystemTag>

Type of optical local 3D point.

Template Parameters

T	data type for coordinate representation

Definition at line 55 of file geo_optical_vectors.h.

using geo::OpticalPoint_t = typedef OpticalPoint3DBase_t<double>

Type of optical 3D point with representation in double precision.

Definition at line 63 of file geo_optical_vectors.h.

template<typename T >

using geo::OpticalVector3DBase_t = typedef GenVector3DBase_t<T, OpticalLocalCoordinateSystemTag>

Type of optical local 3D displacement vector.

Template Parameters

T	data type for coordinate representation

Definition at line 49 of file geo_optical_vectors.h.

using geo::OpticalVector_t = typedef OpticalVector3DBase_t<double>

Type of optical 3D displacement vector with representation in double precision.

Definition at line 60 of file geo_optical_vectors.h.

typedef enum geo::_plane_orient geo::Orient_t

template<typename C >

using geo::Point3DBase_t = typedef GenPoint3DBase_t<double, C>

Type of 3D point with representation in double precision.

Template Parameters

C	coordinate system tag

Definition at line 92 of file geo_vectors.h.

typedef ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag > geo::Point_t

Type for representation of position in physical 3D space.

A point represents a position in 3D space. As such, it makes no sense to add points, and the difference between two points is not a point any more (it is, in fact, a geo::Vector_t). Scaling and norm of a point also have no meaning.

A vector can be added to a point, resulting in another point.

Note that middlePoint() function and MiddlePointAccumulator class are provided to facilitate the computation of a middle point using any type of vector and in particular geo::Point_t.

Definition at line 184 of file geo_vectors.h.

template<typename CoordSystemTag >

using geo::PointIn_t = typedef Point3DBase_t<CoordSystemTag>

Type for representation of positions in 3D space.

Template Parameters

CoordSystemTag

the coordinate system tag for this point

This point type is equivalent to geo::Point_t but it's tagged as from a different coordinate system.

Definition at line 205 of file geo_vectors.h.

typedef ROOT::Math::Rotation3D geo::Rotation_t

Type for representation of space rotations.

Definition at line 209 of file geo_vectors.h.

typedef enum geo::_plane_sigtype geo::SigType_t

using geo::TransformationMatrix = typedef ROOT::Math::Transform3D

Type of transformation matrix used in geometry.

This type is used for storing the transformation matrices of the various geometry description objects (e.g. geo::WireGeo, geo::OpDetGeo, ...).

Definition at line 30 of file TransformationMatrix.h.

template<typename C >

using geo::Vector3DBase_t = typedef GenVector3DBase_t<double, C>

Type of 3D displacement vector with representation in double precision.

Template Parameters

C	coordinate system tag

Definition at line 87 of file geo_vectors.h.

typedef ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag > geo::Vector_t

Type for representation of momenta in 3D space.

A vector represents a direction and intensity, or a displacement respect to an unspecified starting point. Vectors can be added or subtracted, resulting in still a vector. Their modulus can also be scaled.

Definition at line 164 of file geo_vectors.h.

template<typename CoordSystemTag >

using geo::VectorIn_t = typedef Vector3DBase_t<CoordSystemTag>

Type for representation of momenta in 3D space.

Template Parameters

CoordSystemTag

the coordinate system tag for this vector

This vector type is equivalent to geo::Vector_t but it's tagged as from a different coordinate system.

Definition at line 195 of file geo_vectors.h.

typedef enum geo::_plane_proj geo::View_t

Enumerate the possible plane projections.

using geo::WirePtr = typedef WireGeo const*

Definition at line 48 of file PlaneGeo.h.

Enumeration Type Documentation

enum geo::_plane_orient

Enumerator
kHorizontal	Planes that are in the horizontal plane.
kVertical	Planes that are in the vertical plane (e.g. ArgoNeuT).

Definition at line 139 of file geo_types.h.

                             {
    kHorizontal, ///< Planes that are in the horizontal plane.
    kVertical    ///< Planes that are in the vertical plane (e.g. ArgoNeuT).
  } Orient_t;

enum geo::_plane_proj

Enumerate the possible plane projections.

Enumerator
kU	Planes which measure U.
kV	Planes which measure V.
kW	Planes which measure W (third view for Bo, MicroBooNE, etc).
kZ	Planes which measure Z direction.
kY	Planes which measure Y direction.
kX	Planes which measure X direction.
k3D	3-dimensional objects, potentially hits, clusters, prongs, etc.
kUnknown	Unknown view.

Definition at line 128 of file geo_types.h.

                           {
    kU,       ///< Planes which measure U.
    kV,       ///< Planes which measure V.
    kW,       ///< Planes which measure W (third view for Bo, MicroBooNE, etc).
    kZ=kW,    ///< Planes which measure Z direction.
    kY,       ///< Planes which measure Y direction.
    kX,       ///< Planes which measure X direction.
    k3D,      ///< 3-dimensional objects, potentially hits, clusters, prongs, etc.
    kUnknown  ///< Unknown view.
  } View_t;

enum geo::_plane_sigtype

Enumerator
kInduction	Signal from induction planes.
kCollection	Signal from collection planes.
kMysteryType	Who knows?

Definition at line 144 of file geo_types.h.

                              {
    kInduction,   ///< Signal from induction planes.
    kCollection,  ///< Signal from collection planes.
    kMysteryType  ///< Who knows?
  } SigType_t;

enum geo::coordinates

Enumerator
kXCoord	X coordinate.
kYCoord	Y coordinate.
kZCoord	Z coordinate.

Definition at line 121 of file geo_types.h.

                           {
    kXCoord, ///< X coordinate.
    kYCoord, ///< Y coordinate.
    kZCoord  ///< Z coordinate.
  } Coord_t;

enum geo::driftdir

Drift direction: positive or negative.

Do not use this type to distinguish different drift axes: e.g., negative x drift and negative z drift are both by kNeg.

Enumerator
kUnknownDrift	Drift direction is unknown.
kPos	Drift towards positive values.
kNeg	Drift towards negative values.
kPosX	Drift towards positive X values.
kNegX	Drift towards negative X values.

Definition at line 157 of file geo_types.h.

                        {
    kUnknownDrift, ///< Drift direction is unknown.
    kPos,          ///< Drift towards positive values.
    kNeg,          ///< Drift towards negative values.
    kPosX = kPos,  ///< Drift towards positive X values.
    kNegX = kNeg   ///< Drift towards negative X values.
  } DriftDirection_t;

Function Documentation

geo::DriftPartitions geo::buildDriftVolumes

(

geo::CryostatGeo const &

cryo

)

Creates a DriftPartitions object from the TPCs in a cryostat.

Parameters

cryo	the cryostat with the TPCs to be partitioned.

The algorithm groups all TPCs with the same drift direction and readout planes with similar drift coordinates. A "global drift direction" is chosen. The drift directions of all TPCs in the cryostat are required to be parallel (at most with different verse). Projections of the TPC wire planes on this direction determine TPC grouping. TPCs with planes within a small range (typically, 10 plane pitches) of this projected coordinate are grouped together. TPCs with opposite drift directions are still kept in different groups.

The information of each drift volume is kept in a DriftVolume_t class which contains a hierarchical structure of type geo::part::Partition (with data geo::TPCGeo const coming directly from the geometry). This structure describes the topology of the TPCs within the drift volume.

Definition at line 1099 of file DriftPartitions.cxx.

                                                                    {

  //
  // group TPCs by drift direction
  //
  auto TPCsByDriftDir = groupTPCsByDriftDir(cryo);

  //
  // determine the cryostat-wide drift direction (arbitrary but consistent)
  // and the decomposition base (using the same for all drift partitions);
  //

  // In practice we use the coordinate system from the first TPC;
  // we still check that all drift directions are compatible,
  // but the result of detection is ignored.
  /* auto globalDriftDir = */ detectGlobalDriftDir(keys(TPCsByDriftDir));
  using Direction_t = geo::DriftPartitions::Direction_t;
  geo::TPCGeo const& firstTPC = cryo.TPC(0);
  geo::DriftPartitions::Decomposer_t decomposer
    ({ cryo.Center(), firstTPC.RefWidthDir<Direction_t>(), firstTPC.RefDepthDir<Direction_t>() });

  //
  // further group TPCs by plane position in drift direction
  //
  std::vector<TPCgroup_t> TPCgroups;
  for (auto const& TPCsOnDriftDir: TPCsByDriftDir) {
    auto TPCs = sortTPCsByDriftCoord(TPCsOnDriftDir.second, decomposer);
    append(TPCgroups, groupByDriftCoordinate(TPCs));
  } // for

  //
  // verify coordinate system consistency between TPCs
  //
  for (auto const& TPCgroup: TPCgroups) {
    unsigned int errors = checkTPCcoords(TPCgroup.TPCs);
    if (errors > 0) {
      throw cet::exception("buildDriftVolumes")
        << "TPCs in partition have different drift directions ("
        << errors << " errors found in " << TPCgroup.TPCs.size() << " TPCs).\n";
    } // if
  } // for

  //
  // partition each group
  //
  geo::DriftPartitions partitions(decomposer);
  for (auto const& TPCgroup: TPCgroups) {
    auto TPCs = addAreaToTPCs(TPCgroup.TPCs, decomposer);
    auto part = makePartition(TPCs);
    if (!part) {
      cet::exception e("buildDriftVolumes");
      e << "Failed to construct partition out of " << TPCs.size() << " TPCs:";
      for (auto const& TPCinfo: TPCs) {
        e << "\n at " << TPCinfo.area() << " TPC ";
        TPCinfo.TPC->PrintTPCInfo(e, "   ", 5U);
      } // for
      throw e;
    } // if error
    partitions.addPartition(std::move(part));
  } // for

  return partitions;
} // geo::buildDriftVolumes()

double geo::ClosestApproach ( const double  point[], const double  intercept[], const double  slopes[], double  closest[]  )

inline

Find the distance of closest approach between point and line

Parameters

point	- xyz coordinates of point
intercept	- xyz coodinates of point on line
slopes	- unit vector direction (need not be normalized)
closest	- on output, point on line that is closest

Returns

distance from point to line

Definition at line 96 of file geo.h.

{
  double s =
    (slopes[0]*(point[0]-intercept[0]) +
     slopes[1]*(point[1]-intercept[1]) +
     slopes[2]*(point[2]-intercept[2]));
  double sd =
    (slopes[0]*slopes[0] +
     slopes[1]*slopes[1] +
     slopes[2]*slopes[2]);
  if (sd>0.0) {
    s /= sd;
    closest[0] = intercept[0] + s*slopes[0];
    closest[1] = intercept[1] + s*slopes[1];
    closest[2] = intercept[2] + s*slopes[2];
  }
  else {
    // How to handle this zero gracefully? Assume that the intercept
    // is a particle vertex and "slopes" are momenta. In that case,
    // the particle goes nowhere and the closest approach is the
    // distance from the intercept to point
    closest[0] = intercept[0];
    closest[1] = intercept[1];
    closest[2] = intercept[2];
  }
  return std::sqrt(pow((point[0]-closest[0]),2)+
              pow((point[1]-closest[1]),2)+
              pow((point[2]-closest[2]),2));
}

template<typename Dest , typename Src >

decltype(auto) geo::convertTransformationMatrix

(

Src &&

trans

)

Converts a transformation matrix into Dest format.

Definition at line 323 of file LocalTransformation.h.

    {
      return details::TransformationMatrixConverter
        <std::decay_t<Dest>, std::decay_t<Src>>::convert
        (std::forward<Src>(trans));
    }

bool geo::CrossesBoundary ( double  x0[], double  gradient[], double  x_lo, double  x_hi, double  y_lo, double  y_hi, double  z_lo, double  z_hi, double  point[]  )

inline

Determine whether or not track intersects box of volume: ( x_hi - x_lo ) x ( y_hi - y_lo ) x ( z_hi - z_lo )

Parameters

x_hi	- x box coordinates in space w.r.t. the origin
x_lo	- x box coordinates in space w.r.t. the origin
y_hi	- y box coordinates in space w.r.t. the origin
y_lo	- y box coordinates in space w.r.t. the origin
z_hi	- z box coordinates in space w.r.t. the origin
z_lo	- z box coordinates in space w.r.t. the origin
x0[]	- initial position of the particle
gradient[]	- initial gradient of particle position
point[]	(output) - position of the particle at intersection

See also

geo::BoxBoundedGeo::GetIntersection()

*** assumes particle's track is linear

Definition at line 148 of file geo.h.

{

  double distance[3]; // distance to plane

  // puts box coordinates into more useful vectors (for loop later)
  double lo[3] = { x_lo , y_lo , z_lo };
  double hi[3] = { x_hi , y_hi , z_hi };

  // puts box coordinates into more useful vector (for loop later)
  double facecoord[6] = { lo[0] , hi[0] ,
                          lo[1] , hi[1] ,
                          lo[2] , hi[2] };

  int intersect[6]={0,0,0,0,0,0}; // initialize intersection tally vector
  int count=0;
  // iterates through spatial axes (0,1,2) = (x,y,z)
  for(int i=0; i<3; i++) {
    // try both planes with normal parallel to axis
    for(int p=0; p<2; p++ ) {

      point[i] = facecoord[count];           // point on face
      distance[i] = point[i] - x0[i];        // calculate x-coordinate of track distance

      double C_dg = distance[i] / gradient[i];  // calculate correlation b/w gradient and distance

      for(int m=0; m<3; m++){ distance[m] = C_dg * gradient[m];     }
      for(int n=0; n<3; n++){    point[n] = x0[n] + distance[n]; }

      int j, k;
      switch (i) {
        case 0: j=1; k=2; break;
        case 1: j=2; k=0; break;
        case 2: j=0; k=1; break;
        default:
          throw std::logic_error("Big trouble");
      } // switch

      // now want to check to see if the point is in the right plane
      if ( lo[j] < point[j] && point[j] < hi[j]
           && lo[k] < point[k] && point[k] < hi[k] ) {

        //           double length = std::sqrt( distance[0]*distance[0]
        //                               + distance[1]*distance[1]
        //                               + distance[2]*distance[2] );

        // direction of motion w.r.t. start point
        int direction = distance[i]*gradient[i]
          / std::sqrt( (distance[i]*distance[i]) * (gradient[i]*gradient[i]) );
        bool directed = ( direction + 1 ) / 2;

        // checks if particle passes through face
        // and also checks to see whether it passes inward or outward
        //if ( track_length > length && directed ) {
        if ( directed ) {
          int normal = pow( -1 , count + 1 );
          int thru = normal * gradient[i] / std::sqrt(gradient[i]*gradient[i]) ;
          intersect[count]=thru;
        }
      }
      count++;
    }
  }

  // count faces it passes through,
  // ... not necessary now, but maybe useful in the future
  int passes=0;
  for ( int face=0; face<6; ++face ) {
    passes+=(intersect[face]*intersect[face]);
  }

  if ( passes==0 ) {
    return 0;
  } else {
    return 1;
  }
}

template<>

geo::PlaneID geo::GeometryCore::GetBeginID< geo::PlaneID, geo::CryostatID > ( geo::CryostatID const &  id ) const

inline

Definition at line 5819 of file GeometryCore.h.

    { return GetBeginPlaneID(id); }

template<>

geo::TPCID geo::GeometryCore::GetBeginID< geo::TPCID, geo::CryostatID > ( geo::CryostatID const &  id ) const

inline

Definition at line 5809 of file GeometryCore.h.

    { return GetBeginTPCID(id); }

template<>

geo::PlaneID geo::GeometryCore::GetEndID< geo::PlaneID, geo::CryostatID > ( geo::CryostatID const &  id ) const

inline

Definition at line 5824 of file GeometryCore.h.

    { return GetEndPlaneID(id); }

template<>

geo::TPCID geo::GeometryCore::GetEndID< geo::TPCID, geo::CryostatID > ( geo::CryostatID const &  id ) const

inline

Definition at line 5814 of file GeometryCore.h.

    { return GetEndTPCID(id); }

template<typename Point , typename Vector >

Point geo::LineClosestPoint	(	Point const &	startA,
		Vector const &	dirA,
		Point const &	startB,
		Vector const &	dirB
	)

Returns the point of a line that is closest to a second line.

Template Parameters

Point	a type describing a point
Vector	a type describing a direction (displacement vector)

Parameters

refA	a reference point on the first line
dirA	the direction of the first line
refB	a reference point on the second line
dirB	the direction of the second line

Returns

the point of A closest to B

See also

LineClosestPointAndOffsets(), LineClosestPointWithUnitVectors()

The point of line A that is closest to line B is returned.

The two lines are assumed not to be parallel, and when this prerequisite is not met the behaviour is undefined.

Note

This formulation is valid for lines in a Euclidean space of any dimension; the minimized distance is the Euclidean one.

A separate function, LineClosestPointAndOffsets(), also returns the offset of the intersection from the two reference points.

Requirements

The following operations between points, vectors and scalars must be defined:

• Vector operator- (Point, Point): the difference of two points always exists and it returns a Vector;
• Point operator+ (Point, Vector): translation of a point by a displacement vector;
• Vector operator* (Vector, double): vector scaling by a real factor;
• double dot(Vector, Vector): scalar (inner) product of two vectors.

template<typename Point , typename Vector >

IntersectionPointAndOffsets<Point> geo::LineClosestPointAndOffsets	(	Point const &	startA,
		Vector const &	dirA,
		Point const &	startB,
		Vector const &	dirB
	)

Returns the point of a line that is closest to a second line.

Template Parameters

Point	a type describing a point
Vector	a type describing a direction (displacement vector)

Parameters

refA	a reference point on the first line
dirA	the direction of the first line
refB	a reference point on the second line
dirB	the direction of the second line

Returns

a data structure with three fields: point: the point of A closest to B, offset1: its offset on A in units of dirA, offset2: its offset on B in units of dirB

See also

LineClosestPointWithUnitVectors()

LineClosestPointAndOffsets()

The point of line A that is closest to line B is returned.

This function is equivalent to LineClosestPoint(), but it returns in addition the offsets of the intersection point from the reference points of the two lines, in the direction specified by dirA/dirB.

The return value is a data structure of type geo::IntersectionPointAndOffsets, which is most easily unpacked immediately:

auto [ point, offsetA, offsetB ] = geo::LineClosestPointAndOffsets(
  geo::Point_t{ 2, 0, 1 }, geo::Vector_t{ 0.0,   0.5, 0.0 },
  geo::Point_t{ 0, 1, 0 }, geo::Vector_t{ 0.866, 0.0, 0.0 }
  );

will set point to geo::Point{ 2, 1, 1 }, offsetA to 2 and offsetB to 2.309.... To reassign the variables after they have been defined, though, a temporary structure is needed:

auto const xsectAndOfs = geo::LineClosestPointAndOffsets(
  geo::Point_t{ 0, 1, 0 }, geo::Vector_t{ 0.866, 0.0, 0.0 },
  geo::Point_t{ 2, 0, 1 }, geo::Vector_t{ 0.0,   0.5, 0.0 }
  );
point = xsectAndOfs.point;
offsetA = xsectAndOfs.offset1;
offsetB = xsectAndOfs.offset2;

(point to geo::Point{ 2, 1, 0 }, offsetA to 2.039... and offsetB to 2, because the intersection point is always on the first line).

template<typename Point , typename UnitVector >

IntersectionPointAndOffsets<Point> geo::LineClosestPointAndOffsetsWithUnitVectors	(	Point const &	startA,
		UnitVector const &	dirA,
		Point const &	startB,
		UnitVector const &	dirB
	)

Returns the point of a line that is closest to a second line.

Template Parameters

Point	a type describing a point
UnitVector	a type describing a direction (unit vector)

Parameters

refA	a reference point on the first line
dirA	the direction of the first line (unity-normed)
refB	a reference point on the second line
dirB	the direction of the second line (unity-normed)

Returns

a data structure with three fields: point: the point of A closest to B, offset1: its offset on A in units of dirA (i.e. unity), offset2: its offset on B in units of dirB (i.e. unity)

See also

LineClosestPointWithUnitVectors()

LineClosestPointAndOffsets()

The point of line A that is closest to line B is returned.

The return value is a data structure of type geo::IntersectionPointAndOffsets, which is most easily unpacked immediately:

auto [ point, offsetA, offsetB ] = geo::LineClosestPointAndOffsetsWithUnitVectors(
  geo::Point_t{ 2, 0, 1 }, geo::Vector_t{ 0, 1, 0 },
  geo::Point_t{ 0, 1, 0 }, geo::Vector_t{ 1, 0, 0 }
  );

will set point to geo::Point{ 2, 1, 1 }, offsetA to 1 and offsetB to 2. To reassign the variables after they have been defined, instead:

auto const xsectAndOfs = geo::LineClosestPointAndOffsetsWithUnitVectors(
  geo::Point_t{ 0, 1, 0 }, geo::Vector_t{ 1, 0, 0 },
  geo::Point_t{ 2, 0, 1 }, geo::Vector_t{ 0, 1, 0 }
  );
point = xsectAndOfs.point;
offsetA = xsectAndOfs.offset1;
offsetB = xsectAndOfs.offset2;

(point to geo::Point{ 2, 1, 0 }, offsetA to 2 and offsetB to 1, because the intersection point is always on the first line).

template<typename Point , typename UnitVector >

Point geo::LineClosestPointWithUnitVectors	(	Point const &	startA,
		UnitVector const &	dirA,
		Point const &	startB,
		UnitVector const &	dirB
	)

Returns the point of a line that is closest to a second line.

Template Parameters

Point	a type describing a point
UnitVector	a type describing a direction (unit vector)

Parameters

refA	a reference point on the first line
dirA	the direction of the first line (unity-normed)
refB	a reference point on the second line
dirB	the direction of the second line (unity-normed)

Returns

the point of A closest to B

See also

LineClosestPointAndOffsetsWithUnitVectors(), LineClosestPoint()

The point of line A that is closest to line B is returned.

The two lines are assumed not to be parallel, and when this prerequisite is not met the behaviour is undefined.

The two directions are required to have norm 1. While formally if this prerequisite is not met the result is undefined, the result will be still mostly correct if their norm departs from unity only by a rounding error. The more the vectors deviate from that condition, the larger the error in the result.

Note

This formulation is valid for lines in a Euclidean space of any dimension; the minimized distance is the Euclidean one.

A separate function, LineClosestPointAndOffsetsWithUnitVectors(), also returne the offset of the intersection from the two reference points.

Requirements

The following operations between points, vectors and scalars must be defined:

• Vector operator* (UnitVector, double): scaling of a unit vector by a real factor to produce a non-unit vector;
• Vector operator- (Point, Point): the difference of two points always exists and it returns a Vector;
• Point operator+ (Point, Vector): translation of a point by a displacement vector;
• double dot(Vector, UnitVector), double dot(UnitVector, UnitVector): scalar (inner) product of one unit vector and a vector, or two unit vectors.

template<typename Trans >

decltype(auto) geo::makeTransformationMatrix

(

Trans &&

trans

)

Converts a transformation matrix into a geo::TransformationMatrix.

Definition at line 35 of file TransformationMatrix.h.

    { return convertTransformationMatrix<geo::TransformationMatrix>(trans); }

constexpr bool geo::operator!= ( CryostatID const &  a, CryostatID const &  b  )

inline

Comparison: the IDs point to different cryostats (validity is ignored)

Definition at line 702 of file geo_types.h.

    { return a.Cryostat != b.Cryostat; }

constexpr bool geo::operator!= ( OpDetID const &  a, OpDetID const &  b  )

inline

Comparison: IDs point to different optical detectors (validity is ignored)

Definition at line 715 of file geo_types.h.

    { return (a.asCryostatID() != b.asCryostatID()) || (a.OpDet != b.OpDet); }

constexpr bool geo::operator!= ( TPCID const &  a, TPCID const &  b  )

inline

Comparison: the IDs point to different TPCs (validity is ignored)

Definition at line 736 of file geo_types.h.

                                                                    {
    return
      (static_cast<CryostatID const&>(a) != static_cast<CryostatID const&>(b))
      || (a.TPC != b.TPC);
  } // operator!= (TPCID, TPCID)

constexpr bool geo::operator!= ( PlaneID const &  a, PlaneID const &  b  )

inline

Comparison: the IDs point to different planes (validity is ignored)

Definition at line 760 of file geo_types.h.

                                                                        {
    return
      (static_cast<TPCID const&>(a) != static_cast<TPCID const&>(b))
      || (a.Plane != b.Plane);
  } // operator!= (PlaneID, PlaneID)

constexpr bool geo::operator!= ( WireID const &  a, WireID const &  b  )

inline

Comparison: the IDs point to different wires (validity is ignored)

Definition at line 784 of file geo_types.h.

                                                                      {
    return
      (static_cast<PlaneID const&>(a) != static_cast<PlaneID const&>(b))
      || (a.Wire != b.Wire);
  } // operator!= (WireID, WireID)

constexpr bool geo::operator< ( CryostatID const &  a, CryostatID const &  b  )

inline

Order cryostats with increasing ID.

Definition at line 706 of file geo_types.h.

    { return a.Cryostat < b.Cryostat; }

constexpr bool geo::operator< ( OpDetID const &  a, OpDetID const &  b  )

inline

Order OpDetID in increasing Cryo, then OpDet.

Definition at line 719 of file geo_types.h.

                                                                       {
    int cmp_res = a.asCryostatID().cmp(b);
    if (cmp_res == 0) // same cryostat: compare optical detectors
      return a.OpDet < b.OpDet;
    else              // return the order of cryostats
      return cmp_res < 0;
  } // operator< (OpDetID, OpDetID)

constexpr bool geo::operator< ( TPCID const &  a, TPCID const &  b  )

inline

Order TPCID in increasing Cryo, then TPC.

Definition at line 743 of file geo_types.h.

                                                                   {
    int cmp_res = (static_cast<CryostatID const&>(a)).cmp(b);
    if (cmp_res == 0) // same cryostat: compare TPC
      return a.TPC < b.TPC;
    else              // return the order of cryostats
      return cmp_res < 0;
  } // operator< (TPCID, TPCID)

constexpr bool geo::operator< ( PlaneID const &  a, PlaneID const &  b  )

inline

Order PlaneID in increasing TPC, then plane.

Definition at line 767 of file geo_types.h.

                                                                       {
    int cmp_res = (static_cast<TPCID const&>(a)).cmp(b);
    if (cmp_res == 0) // same TPC: compare plane
      return a.Plane < b.Plane;
    else              // return the order of TPC
      return cmp_res < 0;
  } // operator< (PlaneID, PlaneID)

constexpr bool geo::operator< ( WireID const &  a, WireID const &  b  )

inline

Definition at line 791 of file geo_types.h.

                                                                     {
    int cmp_res = (static_cast<PlaneID const&>(a)).cmp(b);
    if (cmp_res == 0) // same plane: compare wire
      return a.Wire < b.Wire;
    else              // return the order of planes
      return cmp_res < 0;
  } // operator< (WireID, WireID)

std::ostream& geo::operator<< ( std::ostream &  out, CryostatID const &  cid  )

inline

Generic output of CryostatID to stream.

Definition at line 653 of file geo_types.h.

                                                                         {
    out << "C:" << cid.Cryostat;
    return out;
  } // operator<< (CryostatID)

std::ostream& geo::operator<< ( std::ostream &  out, OpDetID const &  oid  )

inline

Generic output of OpDetID to stream.

Definition at line 660 of file geo_types.h.

                                                                      {
    out << oid.asCryostatID() << " O:" << oid.OpDet;
    return out;
  } // operator<< (OpDetID)

std::ostream& geo::operator<< ( std::ostream &  out, TPCID const &  tid  )

inline

Generic output of TPCID to stream.

Definition at line 667 of file geo_types.h.

                                                                    {
    out << ((CryostatID const&) tid) << " T:" << tid.TPC;
    return out;
  } // operator<< (TPCID)

std::ostream& geo::operator<< ( std::ostream &  out, PlaneID const &  pid  )

inline

Generic output of PlaneID to stream.

Definition at line 674 of file geo_types.h.

                                                                      {
    out << ((TPCID const&) pid) << " P:" << pid.Plane;
    return out;
  } // operator<< (PlaneID)

std::ostream& geo::operator<< ( std::ostream &  out, WireID const &  wid  )

inline

Generic output of WireID to stream.

Definition at line 681 of file geo_types.h.

                                                                     {
    out << ((PlaneID const&) wid) << " W:" << wid.Wire;
    return out;
  } // operator<< (WireID)

constexpr bool geo::operator== ( CryostatID const &  a, CryostatID const &  b  )

inline

Comparison: the IDs point to the same cryostat (validity is ignored)

Definition at line 698 of file geo_types.h.

    { return a.Cryostat == b.Cryostat; }

constexpr bool geo::operator== ( OpDetID const &  a, OpDetID const &  b  )

inline

Comparison: the IDs point to same optical detector (validity is ignored)

Definition at line 711 of file geo_types.h.

    { return (a.asCryostatID() == b.asCryostatID()) && (a.OpDet == b.OpDet); }

constexpr bool geo::operator== ( TPCID const &  a, TPCID const &  b  )

inline

Comparison: the IDs point to the same TPC (validity is ignored)

Definition at line 729 of file geo_types.h.

                                                                    {
    return
      (static_cast<CryostatID const&>(a) == static_cast<CryostatID const&>(b))
      && (a.TPC == b.TPC);
  } // operator== (TPCID, TPCID)

constexpr bool geo::operator== ( PlaneID const &  a, PlaneID const &  b  )

inline

Comparison: the IDs point to the same plane (validity is ignored)

Definition at line 753 of file geo_types.h.

                                                                        {
    return
      (static_cast<TPCID const&>(a) == static_cast<TPCID const&>(b))
      && (a.Plane == b.Plane);
  } // operator== (PlaneID, PlaneID)

constexpr bool geo::operator== ( WireID const &  a, WireID const &  b  )

inline

Comparison: the IDs point to the same wire (validity is ignored)

Definition at line 777 of file geo_types.h.

                                                                      {
    return
      (static_cast<PlaneID const&>(a) == static_cast<PlaneID const&>(b))
      && (a.Wire == b.Wire);
  } // operator== (WireID, WireID)

template<typename Point = Point_t>

constexpr Point geo::origin

(

)

Returns a origin position with a point of the specified type.

Definition at line 227 of file geo_vectors.h.

{ return { 0.0, 0.0, 0.0 }; }

void geo::ProjectToBoxEdge ( const double  xyz[], const double  dxyz[], double  xlo, double  xhi, double  ylo, double  yhi, double  zlo, double  zhi, double  xyzout[]  )

inline

Project along a direction from a particular starting point to the edge of a box

Parameters

xyz	- The starting x,y,z location. Must be inside box.
dxyz	- Direction vector
xlo	- Low edge of box in x
xhi	- Low edge of box in x
ylo	- Low edge of box in y
yhi	- Low edge of box in y
zlo	- Low edge of box in z
zhi	- Low edge of box in z
xyzout	- On output, the position at the box edge

Note: It should be safe to use the same array for input and output.

Definition at line 49 of file geo.h.

{
  // Make sure we're inside the box!
  if( !(xyz[0]>=xlo && xyz[0]<=xhi) ||
      !(xyz[1]>=ylo && xyz[1]<=yhi) ||
      !(xyz[2]>=zlo && xyz[2]<=zhi)  )
    throw cet::exception("ProjectToBoxEdge") << "desired point is not"
                                             << " in the specififed box\n";

  // Compute the distances to the x/y/z walls
  double dx = 99.E99;
  double dy = 99.E99;
  double dz = 99.E99;
  if      (dxyz[0]>0.0) { dx = (xhi-xyz[0])/dxyz[0]; }
  else if (dxyz[0]<0.0) { dx = (xlo-xyz[0])/dxyz[0]; }
  if      (dxyz[1]>0.0) { dy = (yhi-xyz[1])/dxyz[1]; }
  else if (dxyz[1]<0.0) { dy = (ylo-xyz[1])/dxyz[1]; }
  if      (dxyz[2]>0.0) { dz = (zhi-xyz[2])/dxyz[2]; }
  else if (dxyz[2]<0.0) { dz = (zlo-xyz[2])/dxyz[2]; }

  // Choose the shortest distance
  double d = 0.0;
  if      (dx<dy && dx<dz) d = dx;
  else if (dy<dz && dy<dx) d = dy;
  else if (dz<dx && dz<dy) d = dz;

  // Make the step
  for (int i=0; i<3; ++i) {
    xyzout[i] = xyz[i] + dxyz[i]*d;
  }
}

std::string geo::SignalTypeName

(

geo::SigType_t

sigType

)

Returns the name of the specified signal type.

Definition at line 19 of file geo_types.cxx.

                                                  {
  switch (sigType) {
    case geo::kInduction:   return "induction";
    case geo::kCollection:  return "collection";
    case geo::kMysteryType: return "unknown";
  } // switch
  throw std::logic_error(
    "geo::SignalTypeName(): unexpected signal type #"
    + std::to_string(static_cast<int>(sigType))
    );
} // geo::SignalTypeName()

static bool geo::sortAuxDet35 ( const AuxDetGeo &  ad1, const AuxDetGeo &  ad2  )

static

Definition at line 25 of file GeoObjectSorter35.cxx.

  {

    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    ad1.LocalToWorld(local, xyz1);
    ad2.LocalToWorld(local, xyz2);

    // AuxDet groups in 35t may have a couple-cm difference in vertical pos
    // Adjusting for this messes up sorting between the top layers of AuxDets
    float VertEps(0);
    if     ( strncmp( (ad1.TotalVolume())->GetName(), "volAuxDetTrap", 13) == 0 ) VertEps = 13;
    else if( strncmp( (ad1.TotalVolume())->GetName(), "volAuxDetBox",  12) == 0 ) VertEps = 1;

    // First sort all AuxDets into same-y groups
    if( xyz1[1] < xyz2[1] && xyz2[1]-xyz1[1] >= VertEps ) return true;

    // Within a same-y group, sort AuxDets into same-x groups
    if( std::abs(xyz2[1]-xyz1[1]) < VertEps && xyz1[0] < xyz2[0]) return true;

    // Within a same-x, same-y group, sort AuxDets according to z
    if(xyz1[0] == xyz2[0] && std::abs(xyz2[1]-xyz1[1]) < VertEps && xyz1[2] < xyz2[2]) return true;

    // none of those are true, so return false
    return false;

  }

static bool geo::sortAuxDetAPA ( const AuxDetGeo &  ad1, const AuxDetGeo &  ad2  )

static

Definition at line 20 of file GeoObjectSorterAPA.cxx.

  {

    // NOTE: This initial sorting is arbitrary, there
    //       are no APAAlg users using AuxDet yet

    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    ad1.LocalToWorld(local, xyz1);
    ad2.LocalToWorld(local, xyz2);

    // First sort all AuxDets into same-y groups
    if(xyz1[1] < xyz2[1]) return true;

    // Within a same-y group, sort TPCs into same-z groups
    if(xyz1[1] == xyz2[1] && xyz1[2] < xyz2[2]) return true;

    // Within a same-z, same-y group, sort TPCs according to x
    if(xyz1[2] == xyz2[2] && xyz1[1] == xyz2[1] && xyz1[0] < xyz2[0]) return true;

    // none of those are true, so return false
    return false;

  }

static bool geo::sortAuxDetCRM ( const AuxDetGeo &  ad1, const AuxDetGeo &  ad2  )

static

Definition at line 26 of file GeoObjectSorterCRM.cxx.

  {

    // sort based off of GDML name, assuming ordering is encoded
    std::string ad1name = (ad1.TotalVolume())->GetName();
    std::string ad2name = (ad2.TotalVolume())->GetName();

    // assume volume name is "volAuxDet##"
    int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
    int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );

    return ad1Num < ad2Num;

  }

static bool geo::sortAuxDetSensitive35 ( const AuxDetSensitiveGeo &  ad1, const AuxDetSensitiveGeo &  ad2  )

static

Definition at line 55 of file GeoObjectSorter35.cxx.

  {

    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    ad1.LocalToWorld(local, xyz1);
    ad2.LocalToWorld(local, xyz2);

    // AuxDet groups in 35t may have a couple-cm difference in vertical pos
    // Adjusting for this messes up sorting between the top layers of AuxDets
    float VertEps(0);
    if     ( strncmp( (ad1.TotalVolume())->GetName(), "volAuxDetTrapSensitive", 13) == 0 ) VertEps = 13;
    else if( strncmp( (ad1.TotalVolume())->GetName(), "volAuxDetBoxSensitive",  12) == 0 ) VertEps = 1;

    // First sort all AuxDets into same-y groups
    if( xyz1[1] < xyz2[1] && xyz2[1]-xyz1[1] >= VertEps ) return true;

    // Within a same-y group, sort AuxDets into same-x groups
    if( std::abs(xyz2[1]-xyz1[1]) < VertEps && xyz1[0] < xyz2[0]) return true;

    // Within a same-x, same-y group, sort AuxDets according to z
    if(xyz1[0] == xyz2[0] && std::abs(xyz2[1]-xyz1[1]) < VertEps && xyz1[2] < xyz2[2]) return true;

    // none of those are true, so return false
    return false;

  }

static bool geo::sortAuxDetSensitiveAPA ( const AuxDetSensitiveGeo &  ad1, const AuxDetSensitiveGeo &  ad2  )

static

Definition at line 47 of file GeoObjectSorterAPA.cxx.

  {

    // NOTE: This initial sorting is arbitrary, there
    //       are no APAAlg users using AuxDet yet

    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    ad1.LocalToWorld(local, xyz1);
    ad2.LocalToWorld(local, xyz2);

    // First sort all AuxDets into same-y groups
    if(xyz1[1] < xyz2[1]) return true;

    // Within a same-y group, sort TPCs into same-z groups
    if(xyz1[1] == xyz2[1] && xyz1[2] < xyz2[2]) return true;

    // Within a same-z, same-y group, sort TPCs according to x
    if(xyz1[2] == xyz2[2] && xyz1[1] == xyz2[1] && xyz1[0] < xyz2[0]) return true;

    // none of those are true, so return false
    return false;

  }

static bool geo::sortAuxDetSensitiveCRM ( const AuxDetSensitiveGeo &  ad1, const AuxDetSensitiveGeo &  ad2  )

static

Definition at line 43 of file GeoObjectSorterCRM.cxx.

  {

    // sort based off of GDML name, assuming ordering is encoded
    std::string ad1name = (ad1.TotalVolume())->GetName();
    std::string ad2name = (ad2.TotalVolume())->GetName();

    // assume volume name is "volAuxDetSensitive##"
    int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
    int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );

    return ad1Num < ad2Num;

  }

static bool geo::sortAuxDetSensitiveStandard ( const AuxDetSensitiveGeo &  ad1, const AuxDetSensitiveGeo &  ad2  )

static

Definition at line 43 of file GeoObjectSorterStandard.cxx.

  {
    // sort based off of GDML name, assuming ordering is encoded
    std::string ad1name = (ad1.TotalVolume())->GetName();
    std::string ad2name = (ad2.TotalVolume())->GetName();

    // assume volume name is "volAuxDetSensitive##"
    int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
    int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );

    return ad1Num < ad2Num;
  }

static bool geo::sortAuxDetStandard ( const AuxDetGeo &  ad1, const AuxDetGeo &  ad2  )

static

Definition at line 27 of file GeoObjectSorterStandard.cxx.

  {
    // sort based off of GDML name, assuming ordering is encoded
    std::string const& ad1name = ad1.TotalVolume()->GetName();
    std::string const& ad2name = ad2.TotalVolume()->GetName();

    // assume volume name is "volAuxDet##"
    int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
    int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );

    return ad1Num < ad2Num;

  }

static bool geo::sortCryo35 ( const CryostatGeo &  c1, const CryostatGeo &  c2  )

static

Definition at line 88 of file GeoObjectSorter35.cxx.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    c1.LocalToWorld(local, xyz1);
    c2.LocalToWorld(local, xyz2);

    return xyz1[0] < xyz2[0];
  }

static bool geo::sortCryoAPA ( const CryostatGeo &  c1, const CryostatGeo &  c2  )

static

Definition at line 76 of file GeoObjectSorterAPA.cxx.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    c1.LocalToWorld(local, xyz1);
    c2.LocalToWorld(local, xyz2);

    return xyz1[0] < xyz2[0];
  }

static bool geo::sortCryoCRM ( const CryostatGeo &  c1, const CryostatGeo &  c2  )

static

Definition at line 60 of file GeoObjectSorterCRM.cxx.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    c1.LocalToWorld(local, xyz1);
    c2.LocalToWorld(local, xyz2);

    return xyz1[0] < xyz2[0];
  }

static bool geo::sortCryoStandard ( const CryostatGeo &  c1, const CryostatGeo &  c2  )

static

Definition at line 58 of file GeoObjectSorterStandard.cxx.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    c1.LocalToWorld(local, xyz1);
    c2.LocalToWorld(local, xyz2);

    return xyz1[0] < xyz2[0];
  }

bool geo::sortorderOpDet ( const OpDetGeo &  t1, const OpDetGeo &  t2  )

inline

Definition at line 10 of file OpDetSorter.h.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    if(xyz1[0]!=xyz2[0])
      return xyz1[0]>xyz2[0];
    else if(xyz1[2]!=xyz2[2])
      return xyz1[2]>xyz2[2];
    else
    return xyz1[1]>xyz2[1];
  }

static bool geo::sortorderOpDets ( const OpDetGeo &  t1, const OpDetGeo &  t2  )

static

Definition at line 16 of file GeoObjectSorter.cxx.

  {
    double xyz1[3] = {0.}, xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    if(xyz1[2]!=xyz2[2])
      return xyz1[2]>xyz2[2];
    else if(xyz1[1]!=xyz2[1])
      return xyz1[1]>xyz2[1];
    else
      return xyz1[0]>xyz2[0];
  }

static bool geo::sortPlane35 ( const PlaneGeo &  p1, const PlaneGeo &  p2  )

static

Definition at line 136 of file GeoObjectSorter35.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    p1.LocalToWorld(local, xyz1);
    p2.LocalToWorld(local, xyz2);

    //mf::LogVerbatim("sortPlanes35") << "Sorting planes: ("
    //                              << xyz1[0] <<","<< xyz1[1] <<","<< xyz1[2] << ") and ("
    //                              << xyz2[0] <<","<< xyz2[1] <<","<< xyz2[2] << ")";

    return xyz1[0] > xyz2[0];
  }

static bool geo::sortPlaneAPA ( const PlaneGeo &  p1, const PlaneGeo &  p2  )

static

Definition at line 118 of file GeoObjectSorterAPA.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    p1.LocalToWorld(local, xyz1);
    p2.LocalToWorld(local, xyz2);

    return xyz1[0] > xyz2[0];
  }

static bool geo::sortPlaneCRM ( const PlaneGeo &  p1, const PlaneGeo &  p2  )

static

Definition at line 93 of file GeoObjectSorterCRM.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    p1.LocalToWorld(local, xyz1);
    p2.LocalToWorld(local, xyz2);

    // drift direction is negative, plane number increases in drift direction
    return xyz1[0] > xyz2[0];
  }

static bool geo::sortPlaneStandard ( const PlaneGeo &  p1, const PlaneGeo &  p2  )

static

Definition at line 86 of file GeoObjectSorterStandard.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    p1.LocalToWorld(local, xyz1);
    p2.LocalToWorld(local, xyz2);

    // drift direction is negative, plane number increases in drift direction
    if(std::abs(xyz1[0]-xyz2[0]) > DistanceTol)
      return xyz1[0] > xyz2[0];

    //if same drift, sort by z
    if(std::abs(xyz1[2]-xyz2[2]) > DistanceTol)
      return xyz1[2] < xyz2[2];

    //if same z, sort by y
    return xyz1[1] < xyz2[1];
  }

static bool geo::sortTPC35 ( const TPCGeo &  t1, const TPCGeo &  t2  )

static

Definition at line 101 of file GeoObjectSorter35.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    // very useful for aligning volume sorting with GDML bounds
    //  --> looking at this output is one way to find the z-borders between APAs,
    //      which tells soreWire35 to sort depending on z position via "InVertSplitRegion"
    //mf::LogVerbatim("sortTPC35") << "tpx z range = " << xyz1[2] - t1->Length()/2
    //                           << " to " << xyz1[2] + t1->Length()/2;

    // The goal is to number TPCs first in the x direction so that,
    // in the case of APA configuration, TPCs 2c and 2c+1 make up APA c.
    // then numbering will go in y then in z direction.

    // First sort all TPCs into same-z groups
    if(xyz1[2] < xyz2[2]) return true;

    // Within a same-z group, sort TPCs into same-y groups
    if(xyz1[2] == xyz2[2] && xyz1[1] < xyz2[1]) return true;

    // Within a same-z, same-y group, sort TPCs according to x
    if(xyz1[2] == xyz2[2] && xyz1[1] == xyz2[1] && xyz1[0] < xyz2[0]) return true;

    // none of those are true, so return false
    return false;
  }

static bool geo::sortTPCAPA ( const TPCGeo &  t1, const TPCGeo &  t2  )

static

Definition at line 89 of file GeoObjectSorterAPA.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    // The goal is to number TPCs first in the x direction so that,
    // in the case of APA configuration, TPCs 2c and 2c+1 make up APA c.
    // then numbering will go in y then in z direction.

    // First sort all TPCs into same-z groups
    if(xyz1[2] < xyz2[2]) return true;

    // Within a same-z group, sort TPCs into same-y groups
    if(xyz1[2] == xyz2[2] && xyz1[1] < xyz2[1]) return true;

    // Within a same-z, same-y group, sort TPCs according to x
    if(xyz1[2] == xyz2[2] && xyz1[1] == xyz2[1] && xyz1[0] < xyz2[0]) return true;

    // none of those are true, so return false
    return false;
  }

static bool geo::sortTPCCRM ( const TPCGeo &  t1, const TPCGeo &  t2  )

static

Definition at line 73 of file GeoObjectSorterCRM.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    // First sort all TPCs into same-z groups
    if(xyz1[2]<xyz2[2]) return true;

    // Within a same-z group, sort TPCs into same-y groups
    if(xyz1[2] == xyz2[2] && xyz1[1] < xyz2[1]) return true;

    return false;
  }

static bool geo::sortTPCStandard ( const TPCGeo &  t1, const TPCGeo &  t2  )

static

Definition at line 71 of file GeoObjectSorterStandard.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};
    double local[3] = {0.};
    t1.LocalToWorld(local, xyz1);
    t2.LocalToWorld(local, xyz2);

    // sort TPCs according to x
    return xyz1[0] < xyz2[0];
  }

bool geo::sortWireAPA	(	WireGeo &	w1,
		WireGeo &	w2
	)

Definition at line 131 of file GeoObjectSorterAPA.cxx.

                                            {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};

    w1.GetCenter(xyz1); w2.GetCenter(xyz2);

    // we want the wires to be sorted such that the smallest corner wire
    // on the readout end of a plane is wire zero, with wire number
    // increasing away from that wire.

    // if a top TPC, count from top down
    if( xyz1[1]>0 && xyz1[1] > xyz2[1] ) return true;

    // if a bottom TPC, count from bottom up
    if( xyz1[1]<0 && xyz1[1] < xyz2[1] ) return true;

    // sort the all vertical wires to increase in +z direction
    if( xyz1[1] == xyz2[1] && xyz1[2] < xyz2[2] ) return true;

    return false;
  }

bool geo::sortWireCRM	(	WireGeo const &	w1,
		WireGeo const &	w2
	)

Definition at line 107 of file GeoObjectSorterCRM.cxx.

                                                        {

    std::array<double, 3> xyz1, xyz2;
    w1.GetCenter(xyz1.data()); w2.GetCenter(xyz2.data());

    // for dual-phase we have to planes with wires perpendicular to each other
    // sort wires in the increasing coordinate order

    if (std::abs(xyz1[0] - xyz2[0]) < 1.0E-4 && std::abs(xyz1[1] - xyz2[1]) < 1.0E-4 )
      return xyz1[2] < xyz2[2];
    else if (std::abs(xyz1[0] - xyz2[0]) < 1.0E-4 && std::abs(xyz1[2] - xyz2[2]) < 1.0E-4 )
      return xyz1[1] < xyz2[1];
    else if (std::abs(xyz1[1] - xyz2[1]) < 1.0E-4 && std::abs(xyz1[2] - xyz2[2]) < 1.0E-4 )
      return xyz1[0] < xyz2[0];
    else { // don't know what to do
      throw cet::exception("GeoObjectSorterCRM")
        << "Uknown sorting situation for the wires in a plane\n";
    }
  } // sortWireCRM()

static bool geo::sortWireStandard ( WireGeo const &  w1, WireGeo const &  w2  )

static

Definition at line 108 of file GeoObjectSorterStandard.cxx.

  {
    double xyz1[3] = {0.};
    double xyz2[3] = {0.};

    w1.GetCenter(xyz1); w2.GetCenter(xyz2);

    //sort by z first
    if(std::abs(xyz1[2]-xyz2[2]) > DistanceTol)
      return xyz1[2] < xyz2[2];

    //if same z sort by y
    if(std::abs(xyz1[1]-xyz2[1]) > DistanceTol)
      return xyz1[1] < xyz2[1];

    //if same y sort by x
    return xyz1[0] < xyz2[0];
  }

template<typename StoredMatrix , typename ITER >

static StoredMatrix geo::transformationFromPath ( ITER  begin, ITER  end  )

static

Builds a matrix to go from local to world coordinates in one step.

template<typename StoredMatrix >

static StoredMatrix geo::transformationFromPath ( std::vector< TGeoNode const * > const &  path, size_t  depth  )

static

Builds a matrix to go from local to world coordinates in one step.

geo::Point_t geo::WiresIntersection ( geo::WireGeo const &  wireA, geo::WireGeo const &  wireB  )

inline

Returns the point of wireA that is closest to wireB.

Parameters

wireA	the first wire
wireB	the other wire

Returns

the point of wireA closest to wireB

See also

WiresIntersectionAndOffsets()

The point of wireA that is closest to wireB is returned.

The two wires are assumed not to be parallel, and when this prerequisite is not met the behaviour is undefined.

A separate function, WiresIntersectionAndOffsets(), also returns the offset of the intersection from the two reference points.

Definition at line 654 of file WireGeo.h.

{
  
  return LineClosestPointWithUnitVectors(
    wireA.GetCenter<geo::Point_t>(), wireA.Direction<geo::Vector_t>(),
    wireB.GetCenter<geo::Point_t>(), wireB.Direction<geo::Vector_t>()
    );
  
} // geo::WiresIntersection()

geo::IntersectionPointAndOffsets< geo::Point_t > geo::WiresIntersectionAndOffsets ( geo::WireGeo const &  wireA, geo::WireGeo const &  wireB  )

inline

Returns the point of wireA that is closest to wireB.

Parameters

wireA	the first wire
wireB	the other wire

Returns

a data structure with three fields: point: the point of wireA closest to wireB; offset1: its offset on wireA [cm]; offset2: its offset on wireB [cm]

See also

WiresIntersection()

Computes the point of wireA that is closest to wireB.

The returned intersection point is the same as for geo::WiresIntersection(). The return value is actually triplet, though, which is most easily unpacked immediately:

auto [ point, offsetA, offsetB ] = geo::WiresIntersection(wireA, wireB);

The two other elements of the triplets are the distances of the intersection point from the center of this wire (offset in the example) and from the center of the other wire (otherOffset), in centimeters. The sign of the offsets are positive if the intersection points lie on the side pointed by the Direction() of the respective wires.

To reassign the variables after they have been defined, instead:

std::tie(point, offsetB, offsetA) = geo::WiresIntersection(wireB, wireA);

Definition at line 668 of file WireGeo.h.

{
  
  return LineClosestPointAndOffsetsWithUnitVectors(
    wireA.GetCenter<geo::Point_t>(), wireA.Direction<geo::Vector_t>(),
    wireB.GetCenter<geo::Point_t>(), wireB.Direction<geo::Vector_t>()
    );
  
} // geo::WiresIntersectionAndOffsets()

template<typename Vector = Vector_t>

constexpr Vector geo::Xaxis

(

)

Returns a x axis vector of the specified type.

Definition at line 215 of file geo_vectors.h.

{ return { 1.0, 0.0, 0.0 }; }

template<typename Vector = Vector_t>

constexpr Vector geo::Yaxis

(

)

Returns a y axis vector of the specified type.

Definition at line 219 of file geo_vectors.h.

{ return { 0.0, 1.0, 0.0 }; }

template<typename Vector = Vector_t>

constexpr Vector geo::Zaxis

(

)

Returns a z axis vector of the specified type.

Definition at line 223 of file geo_vectors.h.

{ return { 0.0, 0.0, 1.0 }; }