Namespace collecting geometry-related classes utilities. More...

Namespaces
	details

	fhicl
	FHiCL objects representing geometry classes as configuration parameters.

	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	ChannelMapAlg
	Interface for a class providing readout channel mapping to geometry. More...

class	ChannelMapSetupTool
	Interface for a tool creating a channel mapping object. More...

class	ChannelMapStandardAlg

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...

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	GeoNodePath
	Representation of a node and its ancestry. More...

class	GeoObjectSorter

class	GeoObjectSorterStandard

struct	IntersectionPointAndOffsets
	Data structure for return values of `LineClosestPointAndOffsets()`. More...

class	InvalidWireError
	Exception thrown on invalid wire number. More...

class	LocalTransformation
	Class to transform between world and local coordinates. More...

class	LocalTransformationGeo
	Class to transform between world and local coordinates. More...

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	ROOTGeometryNavigator
	Executes an operation on all the nodes of the ROOT geometry. More...

class	ROOTGeoNodeForwardIterator
	Iterator to navigate through all the nodes. More...

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...

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...

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...

Functions
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<>
readout::TPCsetID	GeometryCore::GetBeginID< readout::TPCsetID, CryostatID > (CryostatID const &id) const

template<>
readout::TPCsetID	GeometryCore::GetEndID< readout::TPCsetID, CryostatID > (CryostatID const &id) const

template<>
readout::ROPID	GeometryCore::GetBeginID< readout::ROPID, CryostatID > (CryostatID const &id) const

template<>
readout::ROPID	GeometryCore::GetEndID< readout::ROPID, CryostatID > (CryostatID const &id) const

template<>
readout::ROPID	GeometryCore::GetBeginID< readout::ROPID, readout::TPCsetID > (readout::TPCsetID const &id) const

template<>
readout::ROPID	GeometryCore::GetEndID< readout::ROPID, readout::TPCsetID > (readout::TPCsetID const &id) const

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)

bool	IntersectLines (double A_start_x, double A_start_y, double A_end_x, double A_end_y, double B_start_x, double B_start_y, double B_end_x, double B_end_y, double &x, double &y)
	Computes the intersection between two lines on a plane. More...

bool	IntersectSegments (double A_start_x, double A_start_y, double A_end_x, double A_end_y, double B_start_x, double B_start_y, double B_end_x, double B_end_y, double &x, double &y)
	Computes the intersection between two segments on a plane. More...

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...

Point_t	WiresIntersection (WireGeo const &wireA, WireGeo const &wireB)
	Returns the point of `wireA` that is closest to `wireB`. More...

IntersectionPointAndOffsets< Point_t >	WiresIntersectionAndOffsets (WireGeo const &wireA, 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)
	Comparison: the IDs point to the same cryostat (validity is ignored) More...

Geometry enumerators
enum	coordinates { kXCoord, kYCoord, kZCoord }
	Enumerate the possible plane projections. More...

enum	_plane_proj { kU, kV, kW, kZ = kW, kY, kX, k3D, kUnknown }
	Enumerate the possible plane projections. More...

enum	_plane_orient { kHorizontal, kVertical }
	Enumerate the possible plane projections. More...

enum	_plane_sigtype { kInduction, kCollection, kMysteryType }
	Enumerate the possible plane projections. More...

enum	driftdir { kUnknownDrift, kPos, kNeg, kPosX = kPos, kNegX = kNeg }
	Drift direction: positive or negative. More...

typedef enum geo::coordinates	Coord_t
	Enumerate the possible plane projections. More...

typedef enum geo::_plane_proj	View_t
	Enumerate the possible plane projections. More...

typedef enum geo::_plane_orient	Orient_t
	Enumerate the possible plane projections. More...

typedef enum geo::_plane_sigtype	SigType_t
	Enumerate the possible plane projections. More...

typedef enum geo::driftdir	DriftDirection_t
	Drift direction: positive or negative. More...

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...

Detailed Description

Namespace collecting geometry-related classes utilities.

LArSoft geometry interface.

Detector geometry definition and interface.

ROOT libraries.

Title: SimPhotonCounterALG Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Alg class that counts up sim photons, leading towards comparisons with flashes and flash hypotheses.

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.

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

Enumerate the possible plane projections.

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 78 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 72 of file geo_vectors.h.

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

Definition at line 32 of file LocalTransformation.h.

using geo::GlobalCoords = typedef ROOT::Math::GlobalCoordinateSystemTag

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 146 of file geo_vectors.h.

using geo::Length_t = typedef double

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

Definition at line 133 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 51 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 58 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 46 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 55 of file geo_optical_vectors.h.

typedef enum geo::_plane_orient geo::Orient_t

Enumerate the possible plane projections.

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 88 of file geo_vectors.h.

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

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 180 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 200 of file geo_vectors.h.

using geo::Rotation_t = typedef ROOT::Math::Rotation3D

Type for representation of space rotations.

Definition at line 203 of file geo_vectors.h.

typedef enum geo::_plane_sigtype geo::SigType_t

Enumerate the possible plane projections.

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 29 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 83 of file geo_vectors.h.

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

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 160 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 190 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 45 of file PlaneGeo.h.

Enumeration Type Documentation

enum geo::_plane_orient

Enumerate the possible plane projections.

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

Definition at line 145 of file geo_types.h.

                              {
     kHorizontal, 
     kVertical    
   } 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 134 of file geo_types.h.

                            {
     kU,      
     kV,      
     kW,      
     kZ = kW, 
     kY,      
     kX,      
     k3D,     
     kUnknown 
   } View_t;

enum geo::_plane_sigtype

Enumerate the possible plane projections.

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

Definition at line 150 of file geo_types.h.

                               {
     kInduction,  
     kCollection, 
     kMysteryType 
   } SigType_t;

enum geo::coordinates

Enumerate the possible plane projections.

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

Definition at line 127 of file geo_types.h.

                            {
     kXCoord, 
     kYCoord, 
     kZCoord  
   } 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 162 of file geo_types.h.

                         {
     kUnknownDrift, 
     kPos,          
     kNeg,          
     kPosX = kPos,  
     kNegX = kNeg   
   } 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 1029 of file DriftPartitions.cxx.

References addAreaToTPCs(), geo::DriftPartitions::addPartition(), geo::BoxBoundedGeo::Center(), checkTPCcoords(), geo::DriftPartitions::decomposer, detectGlobalDriftDir(), e, groupByDriftCoordinate(), groupTPCsByDriftDir(), makePartition(), part, geo::TPCGeo::RefDepthDir(), geo::TPCGeo::RefWidthDir(), sortTPCsByDriftCoord(), and geo::CryostatGeo::TPC().

Referenced by geo::DriftPartitions::driftVolumeAt().

 {
 
   //
   // 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(), firstTPC.RefDepthDir()});
 
   //
   // 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 112 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 319 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 157 of file geo.h.

References n.

 {
 
   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<>

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

inline

Definition at line 2639 of file GeometryCore.h.

References geo::GeometryCore::GetBeginROPID().

   {
     return GetBeginROPID(id);
   }

template<>

readout::ROPID geo::GeometryCore::GetBeginID< readout::ROPID, readout::TPCsetID > ( readout::TPCsetID const & id ) const

inline

Definition at line 2653 of file GeometryCore.h.

References geo::GeometryCore::GetBeginROPID().

   {
     return GetBeginROPID(id);
   }

template<>

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

inline

Definition at line 2624 of file GeometryCore.h.

References geo::GeometryCore::GetBeginTPCsetID().

   {
     return GetBeginTPCsetID(id);
   }

template<>

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

inline

Definition at line 2646 of file GeometryCore.h.

References geo::GeometryCore::GetEndROPID().

   {
     return GetEndROPID(id);
   }

template<>

readout::ROPID geo::GeometryCore::GetEndID< readout::ROPID, readout::TPCsetID > ( readout::TPCsetID const & id ) const

inline

Definition at line 2660 of file GeometryCore.h.

References geo::GeometryCore::GetEndROPID().

   {
     return GetEndROPID(id);
   }

template<>

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

inline

Definition at line 2631 of file GeometryCore.h.

References geo::GeometryCore::GetEndTPCsetID().

   {
     return GetEndTPCsetID(id);
   }

bool geo::IntersectLines	(	double	A_start_x,
		double	A_start_y,
		double	A_end_x,
		double	A_end_y,
		double	B_start_x,
		double	B_start_y,
		double	B_end_x,
		double	B_end_y,
		double &	x,
		double &	y
	)

Computes the intersection between two lines on a plane.

Parameters

A_start_x	x coordinate of one point of the first segment
A_start_y	y coordinate of one point of the first segment
A_end_x	x coordinate of another point of the first segment
A_end_y	y coordinate of another point of the first segment
B_start_x	x coordinate of one point of the second segment
B_start_y	y coordinate of one point of the second segment
B_end_x	x coordinate of another point of the second segment
B_end_y	y coordinate of another point of the second segment
x	_(output)_ variable to store the x coordinate of intersection
y	_(output)_ variable to store the y coordinate of intersection

Returns: whether intersection exists

The order of the ends is not relevant. The return value is false if the two segments are parallel. In that case, x and y variables are not changed. Otherwise, they hold the intersection coordinate, even if the intersection point is beyond one or both the segments.

Definition at line 12 of file Intersections.cxx.

References e.

Referenced by geo::GeometryCore::ChannelsIntersect(), and IntersectSegments().

   {
     // Equation from http://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
     // T.Yang Nov, 2014
     // Notation: x => coordinate orthogonal to the drift direction and to the beam direction
     //           y => direction orthogonal to the previous and to beam direction
 
     double const denom =
       (A_start_x - A_end_x) * (B_start_y - B_end_y) - (A_start_y - A_end_y) * (B_start_x - B_end_x);
 
     constexpr lar::util::RealComparisons<double> coordIs{1e-8};
     if (coordIs.zero(denom)) return false;
 
     double const A = (A_start_x * A_end_y - A_start_y * A_end_x) / denom;
     double const B = (B_start_x * B_end_y - B_start_y * B_end_x) / denom;
 
     x = (B_start_x - B_end_x) * A - (A_start_x - A_end_x) * B;
     y = (B_start_y - B_end_y) * A - (A_start_y - A_end_y) * B;
 
     return true;
   }

bool geo::IntersectSegments	(	double	A_start_x,
		double	A_start_y,
		double	A_end_x,
		double	A_end_y,
		double	B_start_x,
		double	B_start_y,
		double	B_end_x,
		double	B_end_y,
		double &	x,
		double &	y
	)

Computes the intersection between two segments on a plane.

Parameters

A_start_x	x coordinate of the start of the first segment
A_start_y	y coordinate of the start of the first segment
A_end_x	x coordinate of the end of the first segment
A_end_y	y coordinate of the end of the first segment
B_start_x	x coordinate of the start of the second segment
B_start_y	y coordinate of the start of the second segment
B_end_x	x coordinate of the end of the second segment
B_end_y	y coordinate of the end of the second segment
x	_(output)_ variable to store the x coordinate of intersection
y	_(output)_ variable to store the y coordinate of intersection

Returns: whether intersection exists and is on both segments

The order of the ends is not relevant. The return value is false if the two segments are parallel, or if their intersection point is not on both the segments. If the segments are parallel, x and y variables are not changed. Otherwise, they hold the intersection coordinate, even if the intersection point is beyond one or both the segments.

Definition at line 44 of file Intersections.cxx.

References IntersectLines(), and lar::util::PointWithinSegments().

   {
     bool const bCross = IntersectLines(
       A_start_x, A_start_y, A_end_x, A_end_y, B_start_x, B_start_y, B_end_x, B_end_y, x, y);
 
     if (bCross) {
       mf::LogWarning("IntersectSegments") << "The segments are parallel!";
       return false;
     }
 
     return lar::util::PointWithinSegments(
       A_start_x, A_start_y, A_end_x, A_end_y, B_start_x, B_start_y, B_end_x, B_end_y, x, y);
   }

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.

Referenced by geo::IntersectionPointAndOffsets< Point >::operator std::tuple< Point &, double &, double & >().

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).

Referenced by geo::IntersectionPointAndOffsets< Point >::operator std::tuple< Point &, double &, double & >().

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).

Referenced by geo::IntersectionPointAndOffsets< Point >::operator std::tuple< Point &, double &, double & >(), and WiresIntersectionAndOffsets().

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.

Referenced by geo::IntersectionPointAndOffsets< Point >::operator std::tuple< Point &, double &, double & >(), and WiresIntersection().

template<typename Trans >

decltype(auto) geo::makeTransformationMatrix ( Trans && trans )

Converts a transformation matrix into a geo::TransformationMatrix.

Definition at line 33 of file TransformationMatrix.h.

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

   {
     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 686 of file geo_types.h.

References geo::CryostatID::Cryostat.

   {
     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 704 of file geo_types.h.

References geo::CryostatID::asCryostatID(), and geo::OpDetID::OpDet.

   {
     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 727 of file geo_types.h.

References geo::TPCID::TPC.

   {
     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 750 of file geo_types.h.

References geo::PlaneID::Plane.

   {
     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 772 of file geo_types.h.

References geo::WireID::Wire.

   {
     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 692 of file geo_types.h.

References geo::CryostatID::Cryostat.

Referenced by lar::range_t< size_type >::borders(), larg4::LArVoxelReadoutGeometry::Construct(), and voronoi2d::BSTNode::setDepth().

   {
     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 710 of file geo_types.h.

References geo::CryostatID::asCryostatID(), geo::CryostatID::cmp(), and geo::OpDetID::OpDet.

   {
     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 734 of file geo_types.h.

References geo::TPCID::TPC.

   {
     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 756 of file geo_types.h.

References geo::PlaneID::Plane.

   {
     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

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

Definition at line 778 of file geo_types.h.

References geo::WireID::Wire.

   {
     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 634 of file geo_types.h.

References geo::CryostatID::Cryostat.

   {
     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 641 of file geo_types.h.

References geo::CryostatID::asCryostatID(), and geo::OpDetID::OpDet.

   {
     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 648 of file geo_types.h.

References geo::TPCID::TPC.

   {
     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 655 of file geo_types.h.

References geo::PlaneID::Plane.

   {
     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 662 of file geo_types.h.

References geo::WireID::Wire.

   {
     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 680 of file geo_types.h.

References geo::CryostatID::Cryostat.

Referenced by geo::details::id_iterator_base< LocalID, GEOID >::operator!=().

   {
     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 698 of file geo_types.h.

References geo::CryostatID::asCryostatID(), and geo::OpDetID::OpDet.

   {
     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 720 of file geo_types.h.

References geo::TPCID::TPC.

   {
     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 744 of file geo_types.h.

References geo::PlaneID::Plane.

   {
     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 766 of file geo_types.h.

References geo::WireID::Wire.

   {
     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 229 of file geo_vectors.h.

Referenced by geoalgo::GeoAlgo::_ClosestPt_(), geoalgo::GeoAlgo::_commonOrigin_(), evgen::RadioGen::addvolume(), microboone::CosmicRemovalAna::analyze(), geoalgo::GeoAlgo::commonOrigin(), lar_pandora::LArPandoraInput::CreatePandoraMCParticles(), geo::PlaneGeo::DetectGeometryDirections(), microboone::CosmicRemovalAna::FillMCInfo(), evd::TWQMultiTPCProjectionView::FindEndPoint(), evd::TWQProjectionView::FindEndPoint(), tca::FitTraj(), util::GeometryUtilities::Get2DPointProjection(), evgen::BaseRadioGen::GetNodeXYZMinMax(), tca::GetOrigin(), util::GeometryUtilities::GetProjectedPoint(), util::GeometryUtilities::GetTimeTicks(), util::GeometryUtilities::GetXYZ(), evd::SimulationDrawer::MCTruthShortText(), shower::TrackShowerSeparationAlg::ProjPoint(), trkf::TrackStatePropagator::propagateToPlane(), trkf::TrackStatePropagator::rotateToPlane(), simb::MCTruth::SetOrigin(), Polygon2D::Size(), and trkf::TrackStatePropagator::TrackStatePropagator().

   {
     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 54 of file geo.h.

References d.

 {
   // 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 18 of file geo_types.cxx.

References kCollection, kInduction, kMysteryType, and util::to_string().

Referenced by geo::WireIDIntersection::operator<(), and geo::GeometryCore::Print().

 {
   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::sortAuxDetSensitiveStandard	(	const AuxDetSensitiveGeo &	ad1,
		const AuxDetSensitiveGeo &	ad2
	)

static

Definition at line 44 of file GeoObjectSorterStandard.cxx.

References geo::AuxDetSensitiveGeo::TotalVolume().

Referenced by geo::GeoObjectSorterStandard::SortAuxDetSensitive().

   {
     // 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 29 of file GeoObjectSorterStandard.cxx.

References geo::AuxDetGeo::TotalVolume().

Referenced by geo::GeoObjectSorterStandard::SortAuxDets().

   {
     // 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::sortCryoStandard	(	const CryostatGeo &	c1,
		const CryostatGeo &	c2
	)

static

Definition at line 60 of file GeoObjectSorterStandard.cxx.

References geo::CryostatGeo::toWorldCoords().

Referenced by geo::GeoObjectSorterStandard::SortCryostats().

   {
     CryostatGeo::LocalPoint_t const local{0., 0., 0.};
     auto const xyz1 = c1.toWorldCoords(local);
     auto const xyz2 = c2.toWorldCoords(local);
     return xyz1.X() < xyz2.X();
   }

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

static

Definition at line 82 of file GeoObjectSorterStandard.cxx.

References util::abs(), and geo::PlaneGeo::toWorldCoords().

Referenced by geo::GeoObjectSorterStandard::SortPlanes().

   {
     PlaneGeo::LocalPoint_t const local{0., 0., 0.};
     auto const xyz1 = p1.toWorldCoords(local);
     auto const xyz2 = p2.toWorldCoords(local);
 
     // drift direction is negative, plane number increases in drift direction
     if (std::abs(xyz1.X() - xyz2.X()) > DistanceTol) return xyz1.X() > xyz2.X();
 
     //if same drift, sort by z
     if (std::abs(xyz1.Z() - xyz2.Z()) > DistanceTol) return xyz1.Z() < xyz2.Z();
 
     //if same z, sort by y
     return xyz1.Y() < xyz2.Y();
   }

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

static

Definition at line 70 of file GeoObjectSorterStandard.cxx.

References geo::TPCGeo::toWorldCoords().

Referenced by geo::GeoObjectSorterStandard::SortTPCs().

   {
     TPCGeo::LocalPoint_t const local{0., 0., 0.};
     auto const xyz1 = t1.toWorldCoords(local);
     auto const xyz2 = t2.toWorldCoords(local);
 
     // sort TPCs according to x
     return xyz1.X() < xyz2.X();
   }

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

static

Definition at line 99 of file GeoObjectSorterStandard.cxx.

References util::abs(), and geo::WireGeo::GetCenter().

Referenced by geo::GeoObjectSorterStandard::SortWires().

   {
     auto const [xyz1, xyz2] = std::make_pair(w1.GetCenter(), w2.GetCenter());
 
     //sort by z first
     if (std::abs(xyz1.Z() - xyz2.Z()) > DistanceTol) return xyz1.Z() < xyz2.Z();
 
     //if same z sort by y
     if (std::abs(xyz1.Y() - xyz2.Y()) > DistanceTol) return xyz1.Y() < xyz2.Y();
 
     //if same y sort by x
     return xyz1.X() < xyz2.X();
   }

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	(	WireGeo const &	wireA,
		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 528 of file WireGeo.h.

References geo::WireGeo::Direction(), geo::WireGeo::GetCenter(), and LineClosestPointWithUnitVectors().

Referenced by geo::WireGeo::IntersectionWith().

 {
   return LineClosestPointWithUnitVectors(
     wireA.GetCenter(), wireA.Direction(), wireB.GetCenter(), wireB.Direction());
 }

geo::IntersectionPointAndOffsets< geo::Point_t > geo::WiresIntersectionAndOffsets	(	WireGeo const &	wireA,
		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 518 of file WireGeo.h.

References geo::WireGeo::Direction(), geo::WireGeo::GetCenter(), and LineClosestPointAndOffsetsWithUnitVectors().

Referenced by geo::GeometryCore::ChannelsIntersect(), and geo::WireGeo::IntersectionAndOffsetsWith().

 {
 
   return LineClosestPointAndOffsetsWithUnitVectors(
     wireA.GetCenter(), wireA.Direction(), wireB.GetCenter(), wireB.Direction());
 }

template<typename Vector = Vector_t>

constexpr Vector geo::Xaxis ( )

Returns a x axis vector of the specified type.

Definition at line 208 of file geo_vectors.h.

Referenced by geo::TPCGeo::ResetDriftDirection(), geo::TPCGeo::TPCGeo(), and geo::PlaneGeo::UpdateView().

   {
     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 215 of file geo_vectors.h.

Referenced by geo::TPCGeo::ResetDriftDirection(), geo::TPCGeo::TPCGeo(), and geo::PlaneGeo::UpdateView().

   {
     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 222 of file geo_vectors.h.

Referenced by geo::TPCGeo::ResetDriftDirection(), geo::TPCGeo::TPCGeo(), and geo::PlaneGeo::UpdateView().

   {
     return {0.0, 0.0, 1.0};
   }

Namespaces

Classes

Typedefs

Functions

Geometry enumerators

Vector types for the standard LArSoft geometry.

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Requirements

Requirements