LArSoft  v08_29_00
Liquid Argon Software toolkit - http://larsoft.org/
geo Namespace Reference

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...
 
struct  ElementLevel
 
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  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  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
 
class  InvalidWireError
 Exception thrown on invalid wire number. More...
 
class  InvalidWireIDError
 Exception thrown on invalid wire number (e.g. NearestWireID()) More...
 
class  IteratorBox
 
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
 
struct  OpDetID
 The data type to uniquely identify a optical detector. 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  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  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 WirePtr = WireGeo const *
 
using TransformationMatrix = ROOT::Math::Transform3D
 Type of transformation matrix used in geometry. More...
 
using cryostat_id_iterator = details::cryostat_id_iterator_base< geo::CryostatID >
 Forward iterator browsing all cryostats in the detector. More...
 
using cryostat_iterator = details::geometry_element_iterator< cryostat_id_iterator >
 Forward iterator browsing all cryostats in the detector. More...
 
using TPC_id_iterator = details::TPC_id_iterator_base< geo::TPCID >
 Forward iterator browsing all TPCs in the detector. More...
 
using TPC_iterator = details::geometry_element_iterator< TPC_id_iterator >
 Forward iterator browsing all TPCs in the detector. More...
 
using plane_id_iterator = details::plane_id_iterator_base< geo::PlaneID >
 Forward iterator browsing all planes in the detector. More...
 
using plane_iterator = details::geometry_element_iterator< plane_id_iterator >
 Forward iterator browsing all planes in the detector. More...
 
using wire_id_iterator = details::wire_id_iterator_base< geo::WireID >
 Forward iterator browsing all wires in the detector. More...
 
using wire_iterator = details::geometry_element_iterator< wire_id_iterator >
 Forward iterator browsing all wires in the detector. More...
 
using TPCset_id_iterator = details::TPCset_id_iterator_base< readout::TPCsetID >
 Forward iterator browsing all TPC sets in the detector. More...
 
using ROP_id_iterator = details::ROP_id_iterator_base< readout::ROPID >
 Forward iterator browsing all readout planes in the detector. More...
 
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<typename 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 sortorderOpDets (const OpDetGeo *t1, const OpDetGeo *t2)
 
static bool sortAuxDetStandard (const AuxDetGeo *ad1, const AuxDetGeo *ad2)
 
static bool sortAuxDetSensitiveStandard (const AuxDetSensitiveGeo *ad1, const AuxDetSensitiveGeo *ad2)
 
static bool sortCryoStandard (const CryostatGeo *c1, const CryostatGeo *c2)
 
static bool sortTPCStandard (const TPCGeo *t1, const TPCGeo *t2)
 
static bool sortPlaneStandard (const PlaneGeo *p1, const PlaneGeo *p2)
 
bool sortWireStandard (WireGeo *w1, WireGeo *w2)
 
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...
 
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.

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== (OpDetID const &a, OpDetID const &b)
 Comparison: the IDs point to same optical detector (validity is ignored) More...
 
bool operator!= (OpDetID const &a, OpDetID const &b)
 Comparison: IDs point to different optical detectors (validity is ignored) More...
 
bool operator< (OpDetID const &a, OpDetID const &b)
 Order OpDetID in increasing Cryo, then OpDet. 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:

  1. geo::Point_t to describe an absolute position in global coordinates
  2. 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:

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

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

Enumerate the possible plane projections.

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
Tdata type for coordinate representation
Ccoordinate system tag (default: global coordinates)

Definition at line 82 of file geo_vectors.h.

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

Type of 3D displacement vector.

Template Parameters
Tdata type for coordinate representation
Ccoordinate system tag (default: global coordinates)

Definition at line 75 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 150 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 137 of file geo_vectors.h.

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
Ccoordinate system tag

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

template<typename CoordSystemTag >
using geo::PointIn_t = typedef Point3DBase_t<CoordSystemTag>

Type for representation of positions in 3D space.

Template Parameters
CoordSystemTagthe coordinate system tag for this point

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

Definition at line 205 of file geo_vectors.h.

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

Type for representation of space rotations.

Definition at line 209 of file geo_vectors.h.

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 30 of file TransformationMatrix.h.

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

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

Template Parameters
Ccoordinate system tag

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

template<typename CoordSystemTag >
using geo::VectorIn_t = typedef Vector3DBase_t<CoordSystemTag>

Type for representation of momenta in 3D space.

Template Parameters
CoordSystemTagthe coordinate system tag for this vector

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

Definition at line 195 of file geo_vectors.h.

Enumerate the possible plane projections.

using geo::WirePtr = typedef WireGeo const*

Definition at line 48 of file PlaneGeo.h.

Enumeration Type Documentation

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

87  {
88  kHorizontal,
89  kVertical
90  } Orient_t;
enum geo::_plane_orient Orient_t
Enumerate the possible plane projections.
Planes that are in the horizontal plane.
Definition: geo_types.h:88
Planes that are in the vertical plane (e.g. ArgoNeuT).
Definition: geo_types.h:89

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

76  {
77  kU,
78  kV,
79  kW,
80  kZ=kW,
81  kY,
82  kX,
83  k3D,
84  kUnknown
85  } View_t;
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
Planes which measure V.
Definition: geo_types.h:78
Unknown view.
Definition: geo_types.h:84
Planes which measure X direction.
Definition: geo_types.h:82
Planes which measure Z direction.
Definition: geo_types.h:80
Planes which measure Y direction.
Definition: geo_types.h:81
3-dimensional objects, potentially hits, clusters, prongs, etc.
Definition: geo_types.h:83
Planes which measure U.
Definition: geo_types.h:77
Planes which measure W (third view for Bo, MicroBooNE, etc).
Definition: geo_types.h:79

Enumerate the possible plane projections.

Enumerator
kInduction 

Signal from induction planes.

kCollection 

Signal from collection planes.

kMysteryType 

Who knows?

Definition at line 92 of file geo_types.h.

92  {
93  kInduction,
94  kCollection,
96  } SigType_t;
Who knows?
Definition: geo_types.h:95
Signal from induction planes.
Definition: geo_types.h:93
enum geo::_plane_sigtype SigType_t
Enumerate the possible plane projections.
Signal from collection planes.
Definition: geo_types.h:94

Enumerate the possible plane projections.

Enumerator
kXCoord 

X coordinate.

kYCoord 

Y coordinate.

kZCoord 

Z coordinate.

Definition at line 69 of file geo_types.h.

69  {
70  kXCoord,
71  kYCoord,
72  kZCoord
73  } Coord_t;
X coordinate.
Definition: geo_types.h:70
enum geo::coordinates Coord_t
Enumerate the possible plane projections.
Z coordinate.
Definition: geo_types.h:72
Y coordinate.
Definition: geo_types.h:71

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

105  {
106  kUnknownDrift,
107  kPos,
108  kNeg,
109  kPosX = kPos,
110  kNegX = kNeg
Drift direction is unknown.
Definition: geo_types.h:106
Drift towards positive values.
Definition: geo_types.h:107
Drift towards negative X values.
Definition: geo_types.h:110
enum geo::driftdir DriftDirection_t
Drift direction: positive or negative.
Drift towards positive X values.
Definition: geo_types.h:109
Drift towards negative values.
Definition: geo_types.h:108

Function Documentation

geo::DriftPartitions geo::buildDriftVolumes ( geo::CryostatGeo const &  cryo)

Creates a DriftPartitions object from the TPCs in a cryostat.

Parameters
cryothe cryostat with the TPCs to be partitioned.

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

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

Definition at line 1099 of file DriftPartitions.cxx.

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

1099  {
1100 
1101  //
1102  // group TPCs by drift direction
1103  //
1104  auto TPCsByDriftDir = groupTPCsByDriftDir(cryo);
1105 
1106  //
1107  // determine the cryostat-wide drift direction (arbitrary but consistent)
1108  // and the decomposition base (using the same for all drift partitions);
1109  //
1110 
1111  // In practice we use the coordinate system from the first TPC;
1112  // we still check that all drift directions are compatible,
1113  // but the result of detection is ignored.
1114  /* auto globalDriftDir = */ detectGlobalDriftDir(keys(TPCsByDriftDir));
1115  using Direction_t = geo::DriftPartitions::Direction_t;
1116  geo::TPCGeo const& firstTPC = cryo.TPC(0);
1118  ({ cryo.Center(), firstTPC.RefWidthDir<Direction_t>(), firstTPC.RefDepthDir<Direction_t>() });
1119 
1120  //
1121  // further group TPCs by plane position in drift direction
1122  //
1123  std::vector<TPCgroup_t> TPCgroups;
1124  for (auto const& TPCsOnDriftDir: TPCsByDriftDir) {
1125  auto TPCs = sortTPCsByDriftCoord(TPCsOnDriftDir.second, decomposer);
1126  append(TPCgroups, groupByDriftCoordinate(TPCs));
1127  } // for
1128 
1129  //
1130  // verify coordinate system consistency between TPCs
1131  //
1132  for (auto const& TPCgroup: TPCgroups) {
1133  unsigned int errors = checkTPCcoords(TPCgroup.TPCs);
1134  if (errors > 0) {
1135  throw cet::exception("buildDriftVolumes")
1136  << "TPCs in partition have different drift directions ("
1137  << errors << " errors found in " << TPCgroup.TPCs.size() << " TPCs).\n";
1138  } // if
1139  } // for
1140 
1141  //
1142  // partition each group
1143  //
1144  geo::DriftPartitions partitions(decomposer);
1145  for (auto const& TPCgroup: TPCgroups) {
1146  auto TPCs = addAreaToTPCs(TPCgroup.TPCs, decomposer);
1147  auto part = makePartition(TPCs);
1148  if (!part) {
1149  cet::exception e("buildDriftVolumes");
1150  e << "Failed to construct partition out of " << TPCs.size() << " TPCs:";
1151  for (auto const& TPCinfo: TPCs) {
1152  e << "\n at " << TPCinfo.area() << " TPC ";
1153  TPCinfo.TPC->PrintTPCInfo(e, " ", 5U);
1154  } // for
1155  throw e;
1156  } // if error
1157  partitions.addPartition(std::move(part));
1158  } // for
1159 
1160  return partitions;
1161 } // geo::buildDriftVolumes()
std::unique_ptr< geo::part::Partition< geo::TPCGeo const > > makePartition(BeginIter beginTPCwithArea, EndIter endTPCwithArea)
Geometry information for a single TPC.
Definition: TPCGeo.h:38
Vector RefWidthDir() const
Return the direction of reference plane width.
Definition: TPCGeo.h:372
std::vector< TPCwithArea_t > addAreaToTPCs(std::vector< geo::TPCGeo const * > const &TPCs, geo::DriftPartitions::Decomposer_t const &decomposer)
Vector RefDepthDir() const
Return the direction of reference plane depth.
Definition: TPCGeo.h:388
geo::DriftPartitions::DriftDir_t detectGlobalDriftDir(Range &&directions)
TString part[npart]
Definition: Style.C:32
std::vector< TPCgroup_t > groupByDriftCoordinate(std::vector< TPCandPos_t > const &TPCs)
std::vector< std::pair< geo::DriftPartitions::DriftDir_t, std::vector< geo::TPCGeo const * > > > groupTPCsByDriftDir(geo::CryostatGeo const &cryo)
Set of drift volumes.
Float_t e
Definition: plot.C:34
unsigned int checkTPCcoords(std::vector< geo::TPCGeo const * > const &TPCs)
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
geo::Vector_t Direction_t
Type representing a direction in 3D space (norm is not constrained).
std::vector< TPCandPos_t > sortTPCsByDriftCoord(std::vector< geo::TPCGeo const * > const &TPCs, geo::DriftPartitions::Decomposer_t const &decomp)
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.

100 {
101  double s =
102  (slopes[0]*(point[0]-intercept[0]) +
103  slopes[1]*(point[1]-intercept[1]) +
104  slopes[2]*(point[2]-intercept[2]));
105  double sd =
106  (slopes[0]*slopes[0] +
107  slopes[1]*slopes[1] +
108  slopes[2]*slopes[2]);
109  if (sd>0.0) {
110  s /= sd;
111  closest[0] = intercept[0] + s*slopes[0];
112  closest[1] = intercept[1] + s*slopes[1];
113  closest[2] = intercept[2] + s*slopes[2];
114  }
115  else {
116  // How to handle this zero gracefully? Assume that the intercept
117  // is a particle vertex and "slopes" are momenta. In that case,
118  // the particle goes nowhere and the closest approach is the
119  // distance from the intercept to point
120  closest[0] = intercept[0];
121  closest[1] = intercept[1];
122  closest[2] = intercept[2];
123  }
124  return std::sqrt(pow((point[0]-closest[0]),2)+
125  pow((point[1]-closest[1]),2)+
126  pow((point[2]-closest[2]),2));
127 }
Float_t s
Definition: plot.C:23
template<typename Dest , typename Src >
decltype(auto) geo::convertTransformationMatrix ( Src &&  trans)

Converts a transformation matrix into Dest format.

Definition at line 321 of file LocalTransformation.h.

322  {
323  return details::TransformationMatrixConverter
324  <std::decay_t<Dest>, std::decay_t<Src>>::convert
325  (std::forward<Src>(trans));
326  }
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.

157 {
158 
159  double distance[3]; // distance to plane
160 
161  // puts box coordinates into more useful vectors (for loop later)
162  double lo[3] = { x_lo , y_lo , z_lo };
163  double hi[3] = { x_hi , y_hi , z_hi };
164 
165  // puts box coordinates into more useful vector (for loop later)
166  double facecoord[6] = { lo[0] , hi[0] ,
167  lo[1] , hi[1] ,
168  lo[2] , hi[2] };
169 
170  int intersect[6]={0,0,0,0,0,0}; // initialize intersection tally vector
171  int count=0;
172  // iterates through spatial axes (0,1,2) = (x,y,z)
173  for(int i=0; i<3; i++) {
174  // try both planes with normal parallel to axis
175  for(int p=0; p<2; p++ ) {
176 
177  point[i] = facecoord[count]; // point on face
178  distance[i] = point[i] - x0[i]; // calculate x-coordinate of track distance
179 
180  double C_dg = distance[i] / gradient[i]; // calculate correlation b/w gradient and distance
181 
182  for(int m=0; m<3; m++){ distance[m] = C_dg * gradient[m]; }
183  for(int n=0; n<3; n++){ point[n] = x0[n] + distance[n]; }
184 
185  int j, k;
186  switch (i) {
187  case 0: j=1; k=2; break;
188  case 1: j=2; k=0; break;
189  case 2: j=0; k=1; break;
190  default:
191  throw std::logic_error("Big trouble");
192  } // switch
193 
194  // now want to check to see if the point is in the right plane
195  if ( lo[j] < point[j] && point[j] < hi[j]
196  && lo[k] < point[k] && point[k] < hi[k] ) {
197 
198  // double length = std::sqrt( distance[0]*distance[0]
199  // + distance[1]*distance[1]
200  // + distance[2]*distance[2] );
201 
202  // direction of motion w.r.t. start point
203  int direction = distance[i]*gradient[i]
204  / std::sqrt( (distance[i]*distance[i]) * (gradient[i]*gradient[i]) );
205  bool directed = ( direction + 1 ) / 2;
206 
207  // checks if particle passes through face
208  // and also checks to see whether it passes inward or outward
209  //if ( track_length > length && directed ) {
210  if ( directed ) {
211  int normal = pow( -1 , count + 1 );
212  int thru = normal * gradient[i] / std::sqrt(gradient[i]*gradient[i]) ;
213  intersect[count]=thru;
214  }
215  }
216  count++;
217  }
218  }
219 
220  // count faces it passes through,
221  // ... not necessary now, but maybe useful in the future
222  int passes=0;
223  for ( int face=0; face<6; ++face ) {
224  passes+=(intersect[face]*intersect[face]);
225  }
226 
227  if ( passes==0 ) {
228  return 0;
229  } else {
230  return 1;
231  }
232 }
Char_t n[5]

Definition at line 5771 of file GeometryCore.h.

5772  { return GetBeginPlaneID(id); }

Definition at line 5761 of file GeometryCore.h.

5762  { return GetBeginTPCID(id); }

Definition at line 5776 of file GeometryCore.h.

5777  { return GetEndPlaneID(id); }

Definition at line 5766 of file GeometryCore.h.

5767  { return GetEndTPCID(id); }
template<typename Trans >
decltype(auto) geo::makeTransformationMatrix ( Trans &&  trans)

Converts a transformation matrix into a geo::TransformationMatrix.

Definition at line 35 of file TransformationMatrix.h.

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

36  { return convertTransformationMatrix<geo::TransformationMatrix>(trans); }
bool geo::operator!= ( CryostatID const &  a,
CryostatID const &  b 
)
inline

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

Definition at line 513 of file geo_types.h.

References geo::CryostatID::Cryostat.

514  { return a.Cryostat != b.Cryostat; }
bool geo::operator!= ( OpDetID const &  a,
OpDetID const &  b 
)
inline

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

Definition at line 526 of file geo_types.h.

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

527  { return (a.asCryostatID() != b.asCryostatID()) || (a.OpDet != b.OpDet); }
bool geo::operator!= ( TPCID const &  a,
TPCID const &  b 
)
inline

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

Definition at line 547 of file geo_types.h.

References geo::TPCID::TPC.

547  {
548  return
549  (static_cast<CryostatID const&>(a) != static_cast<CryostatID const&>(b))
550  || (a.TPC != b.TPC);
551  } // 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 571 of file geo_types.h.

References geo::PlaneID::Plane.

571  {
572  return
573  (static_cast<TPCID const&>(a) != static_cast<TPCID const&>(b))
574  || (a.Plane != b.Plane);
575  } // 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 595 of file geo_types.h.

References geo::WireID::Wire.

595  {
596  return
597  (static_cast<PlaneID const&>(a) != static_cast<PlaneID const&>(b))
598  || (a.Wire != b.Wire);
599  } // operator!= (WireID, WireID)
bool geo::operator< ( CryostatID const &  a,
CryostatID const &  b 
)
inline

Order cryostats with increasing ID.

Definition at line 517 of file geo_types.h.

References geo::CryostatID::Cryostat.

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

518  { return a.Cryostat < b.Cryostat; }
bool geo::operator< ( OpDetID const &  a,
OpDetID const &  b 
)
inline

Order OpDetID in increasing Cryo, then OpDet.

Definition at line 530 of file geo_types.h.

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

530  {
531  int cmp_res = a.asCryostatID().cmp(b);
532  if (cmp_res == 0) // same cryostat: compare optical detectors
533  return a.OpDet < b.OpDet;
534  else // return the order of cryostats
535  return cmp_res < 0;
536  } // operator< (OpDetID, OpDetID)
bool geo::operator< ( TPCID const &  a,
TPCID const &  b 
)
inline

Order TPCID in increasing Cryo, then TPC.

Definition at line 554 of file geo_types.h.

References geo::TPCID::TPC.

554  {
555  int cmp_res = (static_cast<CryostatID const&>(a)).cmp(b);
556  if (cmp_res == 0) // same cryostat: compare TPC
557  return a.TPC < b.TPC;
558  else // return the order of cryostats
559  return cmp_res < 0;
560  } // operator< (TPCID, TPCID)
geo::CryostatID CryostatID
Definition: readout_types.h:45
bool geo::operator< ( PlaneID const &  a,
PlaneID const &  b 
)
inline

Order PlaneID in increasing TPC, then plane.

Definition at line 578 of file geo_types.h.

References geo::PlaneID::Plane.

578  {
579  int cmp_res = (static_cast<TPCID const&>(a)).cmp(b);
580  if (cmp_res == 0) // same TPC: compare plane
581  return a.Plane < b.Plane;
582  else // return the order of TPC
583  return cmp_res < 0;
584  } // 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 602 of file geo_types.h.

References geo::WireID::Wire.

602  {
603  int cmp_res = (static_cast<PlaneID const&>(a)).cmp(b);
604  if (cmp_res == 0) // same plane: compare wire
605  return a.Wire < b.Wire;
606  else // return the order of planes
607  return cmp_res < 0;
608  } // operator< (WireID, WireID)
std::ostream& geo::operator<< ( std::ostream &  out,
CryostatID const &  cid 
)
inline

Generic output of CryostatID to stream.

Definition at line 464 of file geo_types.h.

References geo::CryostatID::Cryostat.

464  {
465  out << "C:" << cid.Cryostat;
466  return out;
467  } // operator<< (CryostatID)
std::ostream& geo::operator<< ( std::ostream &  out,
OpDetID const &  oid 
)
inline

Generic output of OpDetID to stream.

Definition at line 471 of file geo_types.h.

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

471  {
472  out << oid.asCryostatID() << " O:" << oid.OpDet;
473  return out;
474  } // operator<< (OpDetID)
std::ostream& geo::operator<< ( std::ostream &  out,
TPCID const &  tid 
)
inline

Generic output of TPCID to stream.

Definition at line 478 of file geo_types.h.

References geo::TPCID::TPC.

478  {
479  out << ((CryostatID const&) tid) << " T:" << tid.TPC;
480  return out;
481  } // operator<< (TPCID)
geo::CryostatID CryostatID
Definition: readout_types.h:45
std::ostream& geo::operator<< ( std::ostream &  out,
PlaneID const &  pid 
)
inline

Generic output of PlaneID to stream.

Definition at line 485 of file geo_types.h.

References geo::PlaneID::Plane.

485  {
486  out << ((TPCID const&) pid) << " P:" << pid.Plane;
487  return out;
488  } // operator<< (PlaneID)
std::ostream& geo::operator<< ( std::ostream &  out,
WireID const &  wid 
)
inline

Generic output of WireID to stream.

Definition at line 492 of file geo_types.h.

References geo::WireID::Wire.

492  {
493  out << ((PlaneID const&) wid) << " W:" << wid.Wire;
494  return out;
495  } // 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 509 of file geo_types.h.

References geo::CryostatID::Cryostat.

510  { return a.Cryostat == b.Cryostat; }
bool geo::operator== ( OpDetID const &  a,
OpDetID const &  b 
)
inline

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

Definition at line 522 of file geo_types.h.

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

523  { return (a.asCryostatID() == b.asCryostatID()) && (a.OpDet == b.OpDet); }
bool geo::operator== ( TPCID const &  a,
TPCID const &  b 
)
inline

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

Definition at line 540 of file geo_types.h.

References geo::TPCID::TPC.

540  {
541  return
542  (static_cast<CryostatID const&>(a) == static_cast<CryostatID const&>(b))
543  && (a.TPC == b.TPC);
544  } // 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 564 of file geo_types.h.

References geo::PlaneID::Plane.

564  {
565  return
566  (static_cast<TPCID const&>(a) == static_cast<TPCID const&>(b))
567  && (a.Plane == b.Plane);
568  } // 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 588 of file geo_types.h.

References geo::WireID::Wire.

588  {
589  return
590  (static_cast<PlaneID const&>(a) == static_cast<PlaneID const&>(b))
591  && (a.Wire == b.Wire);
592  } // operator== (WireID, WireID)
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.

55 {
56  // Make sure we're inside the box!
57  if( !(xyz[0]>=xlo && xyz[0]<=xhi) ||
58  !(xyz[1]>=ylo && xyz[1]<=yhi) ||
59  !(xyz[2]>=zlo && xyz[2]<=zhi) )
60  throw cet::exception("ProjectToBoxEdge") << "desired point is not"
61  << " in the specififed box\n";
62 
63  // Compute the distances to the x/y/z walls
64  double dx = 99.E99;
65  double dy = 99.E99;
66  double dz = 99.E99;
67  if (dxyz[0]>0.0) { dx = (xhi-xyz[0])/dxyz[0]; }
68  else if (dxyz[0]<0.0) { dx = (xlo-xyz[0])/dxyz[0]; }
69  if (dxyz[1]>0.0) { dy = (yhi-xyz[1])/dxyz[1]; }
70  else if (dxyz[1]<0.0) { dy = (ylo-xyz[1])/dxyz[1]; }
71  if (dxyz[2]>0.0) { dz = (zhi-xyz[2])/dxyz[2]; }
72  else if (dxyz[2]<0.0) { dz = (zlo-xyz[2])/dxyz[2]; }
73 
74  // Choose the shortest distance
75  double d = 0.0;
76  if (dx<dy && dx<dz) d = dx;
77  else if (dy<dz && dy<dx) d = dy;
78  else if (dz<dx && dz<dy) d = dz;
79 
80  // Make the step
81  for (int i=0; i<3; ++i) {
82  xyzout[i] = xyz[i] + dxyz[i]*d;
83  }
84 }
Float_t d
Definition: plot.C:237
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
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().

45  {
46 
47  // sort based off of GDML name, assuming ordering is encoded
48  std::string ad1name = (ad1->TotalVolume())->GetName();
49  std::string ad2name = (ad2->TotalVolume())->GetName();
50 
51  // assume volume name is "volAuxDetSensitive##"
52  int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
53  int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );
54 
55  return ad1Num < ad2Num;
56 
57  }
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().

28  {
29 
30  // sort based off of GDML name, assuming ordering is encoded
31  std::string ad1name = (ad1->TotalVolume())->GetName();
32  std::string ad2name = (ad2->TotalVolume())->GetName();
33 
34  // assume volume name is "volAuxDet##"
35  int ad1Num = atoi( ad1name.substr( 9, ad1name.size()).c_str() );
36  int ad2Num = atoi( ad2name.substr( 9, ad2name.size()).c_str() );
37 
38  return ad1Num < ad2Num;
39 
40  }
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().

62  {
63  double xyz1[3] = {0.}, xyz2[3] = {0.};
64  double local[3] = {0.};
65  c1->LocalToWorld(local, xyz1);
66  c2->LocalToWorld(local, xyz2);
67 
68  return xyz1[0] < xyz2[0];
69  }
TCanvas * c1
Definition: plotHisto.C:7
TCanvas * c2
Definition: plot_hist.C:75
static bool geo::sortorderOpDets ( const OpDetGeo t1,
const OpDetGeo t2 
)
static

Definition at line 16 of file GeoObjectSorter.cxx.

References geo::OpDetGeo::LocalToWorld().

Referenced by geo::GeoObjectSorter::SortOpDets().

17  {
18  double xyz1[3] = {0.}, xyz2[3] = {0.};
19  double local[3] = {0.};
20  t1->LocalToWorld(local, xyz1);
21  t2->LocalToWorld(local, xyz2);
22 
23  if(xyz1[2]!=xyz2[2])
24  return xyz1[2]>xyz2[2];
25  else if(xyz1[1]!=xyz2[1])
26  return xyz1[1]>xyz2[1];
27  else
28  return xyz1[0]>xyz2[0];
29  }
TTree * t1
Definition: plottest35.C:26
TTree * t2
Definition: plottest35.C:36
static bool geo::sortPlaneStandard ( const PlaneGeo p1,
const PlaneGeo p2 
)
static

Definition at line 91 of file GeoObjectSorterStandard.cxx.

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

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

92  {
93  double xyz1[3] = {0.};
94  double xyz2[3] = {0.};
95  double local[3] = {0.};
96  p1->LocalToWorld(local, xyz1);
97  p2->LocalToWorld(local, xyz2);
98 
99  // drift direction is negative, plane number increases in drift direction
100  if(std::abs(xyz1[0]-xyz2[0]) > DistanceTol)
101  return xyz1[0] > xyz2[0];
102 
103  //if same drift, sort by z
104  if(std::abs(xyz1[2]-xyz2[2]) > DistanceTol)
105  return xyz1[2] < xyz2[2];
106 
107  //if same z, sort by y
108  return xyz1[1] < xyz2[1];
109  }
constexpr auto abs(T v)
Returns the absolute value of the argument.
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().

75  {
76  double xyz1[3] = {0.};
77  double xyz2[3] = {0.};
78  double local[3] = {0.};
79  t1->LocalToWorld(local, xyz1);
80  t2->LocalToWorld(local, xyz2);
81 
82  // sort TPCs according to x
83  if(xyz1[0] < xyz2[0]) return true;
84 
85  return false;
86  }
TTree * t1
Definition: plottest35.C:26
TTree * t2
Definition: plottest35.C:36
bool geo::sortWireStandard ( WireGeo w1,
WireGeo w2 
)

Definition at line 113 of file GeoObjectSorterStandard.cxx.

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

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

113  {
114  double xyz1[3] = {0.};
115  double xyz2[3] = {0.};
116 
117  w1->GetCenter(xyz1); w2->GetCenter(xyz2);
118 
119  //sort by z first
120  if(std::abs(xyz1[2]-xyz2[2]) > DistanceTol)
121  return xyz1[2] < xyz2[2];
122 
123  //if same z sort by y
124  if(std::abs(xyz1[1]-xyz2[1]) > DistanceTol)
125  return xyz1[1] < xyz2[1];
126 
127  //if same y sort by x
128  return xyz1[0] < xyz2[0];
129  }
constexpr auto abs(T v)
Returns the absolute value of the argument.
template<typename Vector = Vector_t>
constexpr Vector geo::Xaxis ( )

Returns a x axis vector of the specified type.

Definition at line 215 of file geo_vectors.h.

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

215 { return { 1.0, 0.0, 0.0 }; }
template<typename Vector = Vector_t>
constexpr Vector geo::Yaxis ( )

Returns a y axis vector of the specified type.

Definition at line 219 of file geo_vectors.h.

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

219 { return { 0.0, 1.0, 0.0 }; }
template<typename Vector = Vector_t>
constexpr Vector geo::Zaxis ( )

Returns a z axis vector of the specified type.

Definition at line 223 of file geo_vectors.h.

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

223 { return { 0.0, 0.0, 1.0 }; }