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

Namespaces
	details

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

class	DumpGeometry
	Describes on screen the current geometry. More...

class	ExptGeoHelperInterface
	Interface to a service with detector-specific geometry knowledge. More...

class	Geometry
	The geometry of one entire detector, as served by art. More...

class	GeometryCore
	Description of geometry of one entire detector. More...

struct	GeometryData_t
	Data in the geometry description. More...

class	GeoObjectSorter

class	GeoObjectSorterStandard

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

class	InvalidWireIDError
	Exception thrown on invalid wire number (e.g. NearestWireID()) More...

class	IteratorBox

class	IteratorBoxBase

class	LocalIteratorBox

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

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

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
static bool	opdet_sort (const OpDetGeo t1, const OpDetGeo t2)

static bool	DUNE_opdet_sort (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<typename T >
T	sqr (T v)

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

bool	sortWireStandard (WireGeo w1, WireGeo w2)


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, 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.
bool	operator== (CryostatID const &a, CryostatID const &b)
	Comparison: the IDs point to the same cryostat (validity is ignored) More...

bool	operator!= (CryostatID const &a, CryostatID const &b)
	Comparison: the IDs point to different cryostats (validity is ignored) More...

bool	operator< (CryostatID const &a, CryostatID const &b)
	Order cryostats with increasing ID. More...

bool	operator== (TPCID const &a, TPCID const &b)
	Comparison: the IDs point to the same TPC (validity is ignored) More...

bool	operator!= (TPCID const &a, TPCID const &b)
	Comparison: the IDs point to different TPCs (validity is ignored) More...

bool	operator< (TPCID const &a, TPCID const &b)
	Order TPCID in increasing Cryo, then TPC. More...

bool	operator== (PlaneID const &a, PlaneID const &b)
	Comparison: the IDs point to the same plane (validity is ignored) More...

bool	operator!= (PlaneID const &a, PlaneID const &b)
	Comparison: the IDs point to different planes (validity is ignored) More...

bool	operator< (PlaneID const &a, PlaneID const &b)
	Order PlaneID in increasing TPC, then plane. More...

bool	operator== (WireID const &a, WireID const &b)
	Comparison: the IDs point to the same wire (validity is ignored) More...

bool	operator!= (WireID const &a, WireID const &b)
	Comparison: the IDs point to different wires (validity is ignored) More...

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.

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.

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 85 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 78 of file geo_vectors.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 153 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 140 of file geo_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 95 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 187 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 208 of file geo_vectors.h.

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

Type for representation of space rotations.

Definition at line 212 of file geo_vectors.h.

typedef enum geo::_plane_sigtype geo::SigType_t

Enumerate the possible plane projections.

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 90 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 167 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 198 of file geo_vectors.h.

typedef enum geo::_plane_proj geo::View_t

Enumerate the possible plane projections.

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 86 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 75 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 91 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 68 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 104 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 1102 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<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.

References s.

 {
   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));
 }

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.

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;
   }
 }

static bool geo::DUNE_opdet_sort	(	const OpDetGeo *	t1,
		const OpDetGeo *	t2
	)

static

Todo:: : move dune opdet sorting to appropriate place in dunetpc

Definition at line 50 of file CryostatGeo.cxx.

References geo::OpDetGeo::LocalToWorld().

Referenced by geo::CryostatGeo::CryostatGeo().

   {
     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];
   }

template<>

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

inline

Definition at line 5628 of file GeometryCore.h.

5629 { return GetBeginPlaneID(id); }

template<>

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

inline

Definition at line 5618 of file GeometryCore.h.

5619 { return GetBeginTPCID(id); }

template<>

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

inline

Definition at line 5633 of file GeometryCore.h.

5634 { return GetEndPlaneID(id); }

template<>

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

inline

Definition at line 5623 of file GeometryCore.h.

5624 { return GetEndTPCID(id); }

static bool geo::opdet_sort	(	const OpDetGeo *	t1,
		const OpDetGeo *	t2
	)

static

Definition at line 32 of file CryostatGeo.cxx.

References geo::OpDetGeo::LocalToWorld().

Referenced by geo::CryostatGeo::CryostatGeo().

   {
     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];
   }

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

inline

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

Definition at line 409 of file geo_types.h.

References geo::CryostatID::Cryostat.

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

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

inline

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

Definition at line 425 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)

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

inline

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

Definition at line 449 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)

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

inline

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

Definition at line 473 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)

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

inline

Order cryostats with increasing ID.

Definition at line 413 of file geo_types.h.

References geo::CryostatID::Cryostat.

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

414 { return a.Cryostat < b.Cryostat; }

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

inline

Order TPCID in increasing Cryo, then TPC.

Definition at line 432 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)

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

inline

Order PlaneID in increasing TPC, then plane.

Definition at line 456 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)

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

inline

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

Definition at line 480 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 367 of file geo_types.h.

References geo::CryostatID::Cryostat.

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

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

inline

Generic output of TPCID to stream.

Definition at line 374 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 381 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 388 of file geo_types.h.

References geo::WireID::Wire.

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

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

inline

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

Definition at line 405 of file geo_types.h.

References geo::CryostatID::Cryostat.

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

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

inline

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

Definition at line 418 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)

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

inline

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

Definition at line 442 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)

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

inline

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

Definition at line 466 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 230 of file geo_vectors.h.

Referenced by geoalgo::GeoAlgo::_ClosestPt_(), geoalgo::GeoAlgo::_commonOrigin_(), microboone::CosmicRemovalAna::analyze(), hit::GausHitFinderAna::analyze(), geoalgo::GeoAlgo::commonOrigin(), lar_pandora::LArPandoraInput::CreatePandoraMCParticles(), geo::PlaneGeo::DetectGeometryDirections(), microboone::CosmicRemovalAna::FillMCInfo(), evd::TWQMultiTPCProjectionView::FindEndPoint(), evd::TWQProjectionView::FindEndPoint(), evd::TWQMultiTPCProjectionView::FindLineLength(), evd::TWQProjectionView::FindLineLength(), tca::FitTraj(), util::GeometryUtilities::Get2DPointProjection(), pma::PMAlgCosmicTagger::GetDimensions(), tca::TrajClusterAlg::GetHitCollection(), tca::GetOrigin(), util::GeometryUtilities::GetProjectedPoint(), util::GeometryUtilities::GetTimeTicks(), pma::PMAlgStitching::GetTPCXOffsets(), util::GeometryUtilities::GetXYZ(), evd::SimulationDrawer::MCTruthShortText(), shwf::ShowerReco::produce(), shower::TrackShowerSeparationAlg::ProjPoint(), trkf::TrackStatePropagator::propagateToPlane(), trkf::TrackStatePropagator::rotateToPlane(), simb::MCTruth::SetOrigin(), Polygon2D::Size(), geo::TPCGeo::SortSubVolumes(), tca::TjDirFOM(), and trkf::TrackStatePropagator::TrackStatePropagator().

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

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;
   }
 }

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 27 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 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::sortCryoStandard	(	const CryostatGeo *	c1,
		const CryostatGeo *	c2
	)

static

Definition at line 61 of file GeoObjectSorterStandard.cxx.

References geo::CryostatGeo::LocalToWorld().

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

   {
     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::sortPlaneStandard	(	const PlaneGeo *	p1,
		const PlaneGeo *	p2
	)

static

Definition at line 91 of file GeoObjectSorterStandard.cxx.

References geo::PlaneGeo::LocalToWorld().

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

   {
     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::sortTPCStandard	(	const TPCGeo *	t1,
		const TPCGeo *	t2
	)

static

Definition at line 74 of file GeoObjectSorterStandard.cxx.

References geo::TPCGeo::LocalToWorld().

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

   {
     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
     if(xyz1[0] < xyz2[0]) return true;
 
     return false;
   }

bool geo::sortWireStandard	(	WireGeo *	w1,
		WireGeo *	w2
	)

Definition at line 113 of file GeoObjectSorterStandard.cxx.

References geo::WireGeo::GetCenter().

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

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

T geo::sqr ( T v )

inline

Definition at line 51 of file GeometryCore.cxx.

References geo::GeometryCore::coordIs, and e.

Referenced by recob::Cluster::Cluster(), detinfo::DetectorPropertiesStandard::Eloss(), hit::details::CompiledGausFitCacheBaseStruct::gaus(), MedicalBeam::GenerateBeamDirection(), MedicalBeam::GeneratePrimaries(), geo::GeometryCore::IntersectSegments(), cluster::ClusterParamsAlg::LinearIntegral(), cluster::fuzzyClusterAlg::mergeTrackClusters(), cluster::fuzzyClusterAlg::run_fuzzy_cluster(), lar::util::details::SimplePolyFitterDataBase< T, D >::sqr(), trkf::CosmicTrackerAlg::Track3D(), lar::util::StatCollector< T, W >::Variance(), lar::util::StatCollector2D< T, W >::VarianceX(), and lar::util::StatCollector2D< T, W >::VarianceY().

51 { return v * v; }

template<typename Vector = Vector_t>

constexpr Vector geo::Xaxis ( )

Returns a x axis vector of the specified type.

Definition at line 218 of file geo_vectors.h.

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

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

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

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

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

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