ATLAS Offline Software
Public Member Functions | Public Attributes | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
Trk::TrackingVolume Class Reference

#include <TrackingVolume.h>

Inheritance diagram for Trk::TrackingVolume:
Collaboration diagram for Trk::TrackingVolume:

Public Member Functions

 TrackingVolume ()=default
 Default Constructor. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume. More...
 
 TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< std::vector< DetachedTrackingVolume * >> detachedSubVolumes, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with detached subvolumes. More...
 
 TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< std::vector< DetachedTrackingVolume * >> detachedSubVolumes, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with detached subvolumes. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< const std::vector< TrackingVolume * >> unorderedSubVolumes, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with unordered subvolumes. More...
 
 TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< const std::vector< TrackingVolume * >> unorderedSubVolumes, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with unordered subvolumes. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< const std::vector< Layer * >> arbitraryLayers, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with arbitrary layers. More...
 
 TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< const std::vector< Layer * >> arbitraryLayers, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with arbitrary layers. More...
 
 TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, std::unique_ptr< const std::vector< Layer * >> arbitraryLayers, std::unique_ptr< const std::vector< TrackingVolume * >> unorderedSubVolumes, const Material &matprop, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -. More...
 
 TrackingVolume (const Volume &volume, std::unique_ptr< const std::vector< Layer * >> arbitraryLayers, std::unique_ptr< const std::vector< TrackingVolume * >> unorderedSubVolumes, const Material &matprop, const std::string &volumeName="undefined")
 Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -. More...
 
 TrackingVolume (const TrackingVolume &trVol, Amg::Transform3D &transform)
 copy constructor with shift More...
 
virtual ~TrackingVolume () override
 Destructor. More...
 
const Layer * associatedLayer (const Amg::Vector3D &gp) const
 Return the associated Layer. More...
 
Layer * associatedLayer (const Amg::Vector3D &gp)
 
const Layer * nextLayer (const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool asres=true, bool skipNavLayer=false) const
 Return the next Layer if existing, NULL if no next layer corresponds. More...
 
const Layer * entryLayer (const Amg::Vector3D &gp, const Amg::Vector3D &dir) const
 Return the entry Layer to a TrackingVolume depending on the entry point. More...
 
const Layer * exitLayer (const Amg::Vector3D &gp, const Amg::Vector3D &dir) const
 Return the exit Layer from a TrackingVolume. More...
 
template<class T >
std::vector< LayerIntersection< T > > materialLayersOrdered (const Layer *sLayer, const Layer *eLayer, const T &parameters, PropDirection pDir=alongMomentum, const BoundaryCheck &bchk=true, bool resolveSubSurfaces=false) const
 Return the material layers ordered based on straight line intersections: More...
 
LayerIntersection< Amg::Vector3D > closestMaterialLayer (const Amg::Vector3D &gp, const Amg::Vector3D &dir, PropDirection pDir=alongMomentum, const BoundaryCheck &bchk=true) const
 Return the closest layer with material description. More...
 
const TrackingVolume * associatedSubVolume (const Amg::Vector3D &gp) const
 Return the associated sub Volume, returns THIS if no subVolume exists. More...
 
TrackingVolume * associatedSubVolume (const Amg::Vector3D &gp)
 
const TrackingVolume * nextVolume (const Amg::Vector3D &gp, const Amg::Vector3D &dir, PropDirection pDir=alongMomentum) const
 Return the next volume along the navigation stream. More...
 
const TrackingVolume * nextSubVolume (const Amg::Vector3D &gp, const Amg::Vector3D &dir) const
 Return the next sub Volume if existing, returns THIS if no subVolume exists. More...
 
std::vector< const DetachedTrackingVolume * > assocDetachedSubVolumes (const Amg::Vector3D &gp, double tol) const
 Return the associated detached subvolumes. More...
 
unsigned int layerAttempts (BoundarySurfaceFace exitFace) const
 Layer attempts - as provided by the LayerAttemptCreator. More...
 
unsigned int maxLayerAttempts () const
 Layer attempts - as provided by the LayerAttemptCreator. More...
 
const LayerArray * confinedLayers () const
 Return the subLayer array. More...
 
LayerArray * confinedLayers ()
 Return the subLayer array. More...
 
ArraySpan< Layer const *const > confinedArbitraryLayers () const
 Return the confined subLayer array. More...
 
ArraySpan< Layer *const > confinedArbitraryLayers ()
 Return the confined subLayer array. More...
 
const LayerArray * checkoutConfinedLayers () const
 Return the subLayerarray including the ownership. More...
 
const TrackingVolumeArray * confinedVolumes () const
 Return the subLayer array. More...
 
TrackingVolumeArray * confinedVolumes ()
 Return the subLayer array. More...
 
ArraySpan< DetachedTrackingVolume const *const > confinedDetachedVolumes () const
 Return detached subVolumes - not the ownership. More...
 
ArraySpan< DetachedTrackingVolume *const > confinedDetachedVolumes ()
 
ArraySpan< TrackingVolume const *const > confinedDenseVolumes () const
 Return unordered subVolumes - not the ownership. More...
 
ArraySpan< TrackingVolume *const > confinedDenseVolumes ()
 
const std::string & volumeName () const
 Returns the VolumeName - for debug reason, might be depreciated later. More...
 
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > & boundarySurfaces ()
 Method to return the BoundarySurfaces. More...
 
ConstSharedPtrSpan< BoundarySurface< TrackingVolume > > boundarySurfaces () const
 
template<class T >
std::vector< BoundaryIntersection< T > > boundarySurfacesOrdered (const T &parameters, PropDirection pDir=alongMomentum, bool startOffBoundary=false) const
 Returns the boundary surfaces ordered in probability to hit them based on straight line intersection. More...
 
const BoundarySurface< TrackingVolume > * boundarySurface (const ObjectAccessor::value_type &oa) const
 Get the BoundarySurface to the appointed Accessor state. More...
 
template<class T >
bool onVolumeBoundary (const T &pars) const
 show if you are on a boundary surface More...
 
void registerOutsideGlueVolumes (GlueVolumesDescriptor *gvd)
 Register the outside glue volumes - ordering is in the TrackingVolume Frame: More...
 
GlueVolumesDescriptor & glueVolumesDescriptor ()
 
const GlueVolumesDescriptor & glueVolumesDescriptor () const
 
void sign (GeometrySignature signat, GeometryType gtype=Static)
 sign the volume - the geometry builder has to do that More...
 
GeometrySignature geometrySignature () const
 return the Signature More...
 
GeometryType geometryType () const
 return the Signature More...
 
void registerColorCode (unsigned int icolor)
 Register the color code. More...
 
unsigned int colorCode () const
 Get the color code. More...
 
const TrackingVolume * getMotherVolume () const
 Return the MotherVolume - if it exists. More...
 
void setMotherVolume (const TrackingVolume *mvol)
 set the MotherVolume More...
 
void moveVolume (Amg::Transform3D &shift)
 move Volume More...
 
void addMaterial (const Material &mat, float fact=1.)
 add Material More...
 
virtual bool isAlignable () const
 
void screenDump (MsgStream &msg) const
 
virtual Volume * clone () const
 polymorpic deep copy More...
 
const Amg::Transform3D & transform () const
 Return methods for geometry transform. More...
 
const Amg::Vector3D & center () const
 returns the center of the volume More...
 
const VolumeBounds & volumeBounds () const
 returns the volumeBounds() More...
 
VolumeBounds & volumeBounds ()
 
bool inside (const Amg::Vector3D &gp, double tol=0.) const
 Inside() method for checks. More...
 
ObjectAccessor boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool forceInside=false) const
 Provide accessor for BoundarySurfaces. More...
 
std::unique_ptr< Material > scale (float sf) const
 scaling method More...
 
float zOverAtimesRho () const
 access to members More...
 
float x0 () const
 
float averageZ () const
 
std::string toString () const
 spit out as a string More...
 

Public Attributes

float X0
 
float L0
 
float A
 
float Z
 
float rho
 
float dEdX
 
float zOaTr
 
MaterialComposition * composition
 

Protected Attributes

std::unique_ptr< Amg::Transform3D > m_transform = nullptr
 Transform3D (optional) More...
 
Amg::Vector3D m_center = Trk::s_origin
 center position of the surface More...
 
std::shared_ptr< VolumeBounds > m_volumeBounds = nullptr
 the volumeBounds More...
 

Private Member Functions

void indexContainedStaticLayers (GeometrySignature geoSig, int &offset)
 reIndex the static layers of the TrackingVolume More...
 
void indexContainedMaterialLayers (GeometrySignature geoSig, int &offset)
 reIndex the material layers of the TrackingVolume More...
 
void createBoundarySurfaces ()
 Create Boundary Surface. More...
 
void createLayerAttemptsCalculator ()
 Create Layer Attempts Caluclator. More...
 
void compactify (size_t &rSurfaces, size_t &tSurfaces)
 compactify the memory usage in the event by setting ownership to TackingGeometry the referenced types are the number of registered surfaces & total surfaces More...
 
void synchronizeLayers (MsgStream &msgstream, double envelope=1.)
 method to synchronize the layers with potentially updated volume bounds: More...
 
void interlinkLayers ()
 Register Next - Previous for Layers, set volumelink. More...
 
void moveTV (Amg::Transform3D &transform)
 move the Tracking Volume More...
 
 TrackingVolume (const TrackingVolume &)=delete
 Forbidden copy constructor. More...
 
TrackingVolume & operator= (const TrackingVolume &)=delete
 Forbid assignment. More...
 

Static Private Member Functions

static const Layer * closest (const Amg::Vector3D &pos, const Amg::Vector3D &dir, const Layer &first, const Layer &second)
 Helper method - find closest of two layers. More...
 

Private Attributes

const TrackingVolume * m_motherVolume {nullptr}
 boundary Surfaces, they can be shared between volumes More...
 
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > m_boundarySurfaces {nullptr}
 
std::unique_ptr< LayerArray > m_confinedLayers {nullptr}
 Array of Volumes inside the Volume. More...
 
std::unique_ptr< TrackingVolumeArray > m_confinedVolumes {nullptr}
 Detached subvolumes. More...
 
std::unique_ptr< const std::vector< DetachedTrackingVolume * > > m_confinedDetachedVolumes {nullptr}
 Additionally, Unordered subvolumes (we own the elements) More...
 
std::unique_ptr< const std::vector< TrackingVolume * > > m_confinedDenseVolumes {nullptr}
 Additionally, Unordered Layers inside the Volume (we own the elements) More...
 
std::unique_ptr< const std::vector< Layer * > > m_confinedArbitraryLayers {nullptr}
 
CxxUtils::CachedUniquePtrT< GlueVolumesDescriptor > m_outsideGlueVolumes {nullptr}
 provided the number of layer attempts More...
 
std::unique_ptr< LayerAttemptsCalculator > m_layerAttemptsCalculator {nullptr}
 defines how the Extrapolator propagates through this More...
 
GeometryType m_geometryType {Trk::NumberOfGeometryTypes}
 The Signature done by the GeometryBuilder. More...
 
GeometrySignature m_geometrySignature {Trk::Unsigned}
 
std::string m_name {"undefined"}
 Volume name for debug reasons. More...
 
unsigned int m_colorCode {20}
 Color code for displaying. More...
 

Friends

class TrackingVolumeManipulator
 The TrackingVolumeManipulator has to be a friend. More...
 
class TrackingGeometry
 Give the TrackingGeometry friend rights. More...
 
class DetachedTrackingVolume
 Give the DetachedTrackingVolume friend rights. More...
 

Detailed Description

Full Volume description used in Tracking, it inherits from Volume to get the geometrical structure, such as from MaterialProperties and from MagneticFieldProperties 

A TrackingVolume can provide the (layer) material information / internal

navigation with in 5 different ways: 

    --- a) Static confinement of Layers
    --- b) detached sub volumes
    --- b) unordered (arbitrarily oriented) layers
    --- d) unordered sub volumes
    --- e) unordered layers AND unordered subvolumes

Static configurations can have a BendingCorrector that allows for correction of the path due to the bending of the track 

    --- dedicated entry/exit layers can be defined for holding
        two perpenticular layers that are accessed in an entry/exit action

In addition it is capable of holding a subarray of Layers and TrackingVolumes, Layers and TrackingVolumes are then owned by the TrackingVolume holding them.

Author
Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch
Christos Anastopoulos (Athena MT modifications)

Definition at line 116 of file TrackingVolume.h.

Constructor & Destructor Documentation

◆ TrackingVolume() [1/14]

Trk::TrackingVolume::TrackingVolume ( )
default

Default Constructor.

◆ TrackingVolume() [2/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
std::unique_ptr< LayerArray >  subLayers = nullptr,
std::unique_ptr< TrackingVolumeArray >  subVolumes = nullptr,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume.

  • explicitely ======> 1 a) static confinement

Definition at line 50 of file TrackingVolume.cxx.

56  : Volume(std::move(htrans), std::move(volbounds))
57  , Material()
58  , m_boundarySurfaces{}
59  , m_confinedLayers(std::move(subLayers))
60  , m_confinedVolumes(std::move(subVolumes))
61  , m_name(volumeName)
62 {
63  createBoundarySurfaces();
64  createLayerAttemptsCalculator();
65  interlinkLayers();
66 }

◆ TrackingVolume() [3/14]

Trk::TrackingVolume::TrackingVolume ( const Volume &  volume,
const Material &  matprop,
std::unique_ptr< LayerArray >  subLayers = nullptr,
std::unique_ptr< TrackingVolumeArray >  subVolumes = nullptr,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume.

  • full by inheritance ======> 2 a) static confinement

Definition at line 69 of file TrackingVolume.cxx.

74  : Volume(volume)
75  , Material(matprop)
76  , m_confinedLayers(std::move(subLayers))
77  , m_confinedVolumes(std::move(subVolumes))
78  , m_name(volumeName)
79 {
80  createBoundarySurfaces();
81  createLayerAttemptsCalculator();
82  interlinkLayers();
83 }

◆ TrackingVolume() [4/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
const Material &  matprop,
std::unique_ptr< LayerArray >  subLayers = nullptr,
std::unique_ptr< TrackingVolumeArray >  subVolumes = nullptr,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume.

  • mixed ======> 3 a) static confinement

Definition at line 86 of file TrackingVolume.cxx.

93  : Volume(std::move(htrans), std::move(volbounds))
94  , Material(matprop)
95  , m_confinedLayers(std::move(subLayers))
96  , m_confinedVolumes(std::move(subVolumes))
97  , m_name(volumeName)
98 {
99  createBoundarySurfaces();
100  createLayerAttemptsCalculator();
101  interlinkLayers();
102 }

◆ TrackingVolume() [5/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
const Material &  matprop,
std::unique_ptr< std::vector< DetachedTrackingVolume * >>  detachedSubVolumes,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with detached subvolumes.

  • mixed =======> 1 b) detached volumes

Definition at line 105 of file TrackingVolume.cxx.

111  : Volume(std::move(htrans), std::move(volbounds))
112  , Material(matprop)
113  , m_confinedDetachedVolumes(std::move(detachedSubVolumes))
114  , m_name(volumeName)
115 {
116  createBoundarySurfaces();
117 }

◆ TrackingVolume() [6/14]

Trk::TrackingVolume::TrackingVolume ( const Volume &  volume,
const Material &  matprop,
std::unique_ptr< std::vector< DetachedTrackingVolume * >>  detachedSubVolumes,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with detached subvolumes.

  • mixed =======> 2 b) detached volumes

Definition at line 120 of file TrackingVolume.cxx.

125  : Volume(volume)
126  , Material(matprop)
127  , m_confinedDetachedVolumes(std::move(detachedSubVolumes))
128  , m_name(volumeName)
129 {
130  createBoundarySurfaces();
131 }

◆ TrackingVolume() [7/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
const Material &  matprop,
std::unique_ptr< const std::vector< TrackingVolume * >>  unorderedSubVolumes,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with unordered subvolumes.

  • mixed =======> 1 d) unordered volumes

Definition at line 134 of file TrackingVolume.cxx.

140  : Volume(std::move(htrans), std::move(volbounds))
141  , Material(matprop)
142  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
143  , m_name(volumeName)
144 {
145  createBoundarySurfaces();
146 }

◆ TrackingVolume() [8/14]

Trk::TrackingVolume::TrackingVolume ( const Volume &  volume,
const Material &  matprop,
std::unique_ptr< const std::vector< TrackingVolume * >>  unorderedSubVolumes,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with unordered subvolumes.

  • mixed =======> 2 d) unordered volumes

Definition at line 149 of file TrackingVolume.cxx.

154  : Volume(volume)
155  , Material(matprop)
156  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
157  , m_name(volumeName)
158 {
159  createBoundarySurfaces();
160 }

◆ TrackingVolume() [9/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
const Material &  matprop,
std::unique_ptr< const std::vector< Layer * >>  arbitraryLayers,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with arbitrary layers.

  • mixed =======> 1 c) arbitrarily oriented layers

Definition at line 163 of file TrackingVolume.cxx.

169  : Volume(std::move(htrans), std::move(volbounds))
170  , Material(matprop)
171  , m_confinedArbitraryLayers(std::move(layers))
172  , m_name(volumeName)
173 {
174  createBoundarySurfaces();
175 }

◆ TrackingVolume() [10/14]

Trk::TrackingVolume::TrackingVolume ( const Volume &  volume,
const Material &  matprop,
std::unique_ptr< const std::vector< Layer * >>  arbitraryLayers,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with arbitrary layers.

  • mixed =======> 2 c) arbitrarily oriented layers

Definition at line 178 of file TrackingVolume.cxx.

182  : Volume(volume)
183  , Material(matprop)
184  , m_confinedArbitraryLayers(std::move(layers))
185  , m_name(volumeName)
186 {
187  createBoundarySurfaces();
188 }

◆ TrackingVolume() [11/14]

Trk::TrackingVolume::TrackingVolume ( std::unique_ptr< Amg::Transform3D >  htrans,
std::shared_ptr< VolumeBounds >  volbounds,
std::unique_ptr< const std::vector< Layer * >>  arbitraryLayers,
std::unique_ptr< const std::vector< TrackingVolume * >>  unorderedSubVolumes,
const Material &  matprop,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -.

  • mixed =======> 1 e) unordered layers AND unordered subvolumes

Definition at line 191 of file TrackingVolume.cxx.

198  : Volume(std::move(htrans), std::move(volbounds))
199  , Material(matprop)
200  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
201  , m_confinedArbitraryLayers(std::move(layers))
202  , m_name(volumeName)
203 {
204  createBoundarySurfaces();
205 }

◆ TrackingVolume() [12/14]

Trk::TrackingVolume::TrackingVolume ( const Volume &  volume,
std::unique_ptr< const std::vector< Layer * >>  arbitraryLayers,
std::unique_ptr< const std::vector< TrackingVolume * >>  unorderedSubVolumes,
const Material &  matprop,
const std::string &  volumeName = "undefined" 
)

Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -.

  • mixed =======> 2 e) unordered layers AND unordered subvolumes

Definition at line 208 of file TrackingVolume.cxx.

214  : Volume(volume)
215  , Material(matprop)
216  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
217  , m_confinedArbitraryLayers(std::move(layers))
218  , m_name(volumeName)
219 {
220  createBoundarySurfaces();
221 }

◆ TrackingVolume() [13/14]

Trk::TrackingVolume::TrackingVolume ( const TrackingVolume &  trVol,
Amg::Transform3D &  transform 
)

copy constructor with shift

Definition at line 223 of file TrackingVolume.cxx.

225  : Volume(trVol, transform)
226  , Material(trVol)
227  , m_motherVolume(trVol.m_motherVolume)
228  , m_boundarySurfaces{}
229  , m_name(trVol.m_name)
230  , m_colorCode(trVol.m_colorCode)
231 {
232  // createBoundarySurfaces
233  m_boundarySurfaces.reserve(trVol.boundarySurfaces().size());
234  const Trk::TrackingVolume* in = nullptr;
235  const Trk::TrackingVolume* out = nullptr;
236  for (size_t ib = 0; ib < trVol.boundarySurfaces().size(); ib++) {
237  in = trVol.boundarySurfaces()[ib]->insideVolume() == &trVol ? this : nullptr;
238  out = in == nullptr ? this : nullptr;
239  const Trk::CylinderSurface* cyl =
240  dynamic_cast<const Trk::CylinderSurface*>(trVol.boundarySurfaces()[ib]);
241  const Trk::DiscSurface* dis =
242  dynamic_cast<const Trk::DiscSurface*>(trVol.boundarySurfaces()[ib]);
243  const Trk::PlaneSurface* pla =
244  dynamic_cast<const Trk::PlaneSurface*>(trVol.boundarySurfaces()[ib]);
245  const Trk::SubtractedCylinderSurface* scyl =
246  dynamic_cast<const Trk::SubtractedCylinderSurface*>(
247  trVol.boundarySurfaces()[ib]);
248  const Trk::SubtractedPlaneSurface* spla =
249  dynamic_cast<const Trk::SubtractedPlaneSurface*>(
250  trVol.boundarySurfaces()[ib]);
251  if (scyl) {
252  m_boundarySurfaces.push_back(
253  std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(in, out, *scyl, transform));
254  } else if (spla) {
255  m_boundarySurfaces.push_back(
256  std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(in, out, *spla, transform));
257  } else if (cyl) {
258  m_boundarySurfaces.push_back(
259  std::make_shared<Trk::BoundaryCylinderSurface<Trk::TrackingVolume>>(in, out, *cyl, transform));
260  } else if (dis) {
261  m_boundarySurfaces.push_back(
262  std::make_shared<Trk::BoundaryDiscSurface<Trk::TrackingVolume>>(in, out, *dis, transform));
263  } else if (pla) {
264  m_boundarySurfaces.push_back(
265  std::make_shared<Trk::BoundaryPlaneSurface<Trk::TrackingVolume>>(in, out, *pla, transform));
266  }
267  }
268 
269  // confined layers
270  const Trk::BinnedArray<Trk::Layer>* confinedLayers = trVol.confinedLayers();
271  if (confinedLayers) {
272  std::span<Trk::Layer const* const> layers = confinedLayers->arrayObjects();
273  std::vector<std::shared_ptr<Trk::Layer>> layerOrder;
274  layerOrder.reserve(layers.size());
275  for (const auto *layer : layers) {
276  const Trk::PlaneLayer* lay = dynamic_cast<const Trk::PlaneLayer*>(layer);
277  if (lay) {
278  Trk::PlaneLayer* newlay = new Trk::PlaneLayer(*lay, transform);
279  layerOrder.push_back(std::shared_ptr<Trk::Layer>(newlay));
280  }
281  }
282  const Trk::NavBinnedArray1D<Trk::Layer>* confLays =
283  dynamic_cast<const Trk::NavBinnedArray1D<Trk::Layer>*>(confinedLayers);
284  if (confLays) {
285  m_confinedLayers = std::make_unique<Trk::NavBinnedArray1D<Trk::Layer>>(
286  *confLays,
287  std::vector<std::shared_ptr<Trk::Layer>>(layerOrder),
288  transform);
289  }
290  }
291 
292  // confined 'unordered' layers
293  Trk::ArraySpan<const Trk::Layer* const> confinedArbitraryLayers =
294  trVol.confinedArbitraryLayers();
295  if (!confinedArbitraryLayers.empty()) {
296  // clone & apply the transform
297  std::vector<Trk::Layer*> uLayers;
298  uLayers.reserve(confinedArbitraryLayers.size());
299  for (const auto *confinedArbitraryLayer : confinedArbitraryLayers) {
300  const Trk::SubtractedPlaneLayer* slayer =
301  dynamic_cast<const Trk::SubtractedPlaneLayer*>(
302  confinedArbitraryLayer);
303  const Trk::SubtractedCylinderLayer* sclayer =
304  dynamic_cast<const Trk::SubtractedCylinderLayer*>(
305  confinedArbitraryLayer);
306  const Trk::PlaneLayer* layer =
307  dynamic_cast<const Trk::PlaneLayer*>(confinedArbitraryLayer);
308  const Trk::CylinderLayer* clayer =
309  dynamic_cast<const Trk::CylinderLayer*>(confinedArbitraryLayer);
310 
311  if (slayer) {
312  Trk::SubtractedPlaneLayer* lay = new Trk::SubtractedPlaneLayer(*slayer, transform);
313  uLayers.push_back(lay);
314  } else if (layer) {
315  Trk::PlaneLayer* lay = new Trk::PlaneLayer(*layer, transform);
316  uLayers.push_back(lay);
317  } else if (sclayer) {
318  Trk::SubtractedCylinderLayer* lay = new Trk::SubtractedCylinderLayer(*sclayer, transform);
319  uLayers.push_back(lay);
320  } else if (clayer) {
321  Trk::CylinderLayer* lay = new Trk::CylinderLayer(*clayer, transform);
322  uLayers.push_back(lay);
323  }
324  }
325  m_confinedArbitraryLayers = std::make_unique<std::vector<Trk::Layer*>>(uLayers);
326  }
327 
328  // confined volumes
329  const Trk::BinnedArray<Trk::TrackingVolume>* confinedVolumes =
330  trVol.confinedVolumes();
331  if (confinedVolumes) {
332  // retrieve array objects and apply the transform
333  std::span<Trk::TrackingVolume const * const > volumes =
334  confinedVolumes->arrayObjects();
335  std::vector<std::shared_ptr<Trk::TrackingVolume>> volOrder;
336  volOrder.reserve(volumes.size());
337  for (const auto *volume : volumes) {
338  Trk::TrackingVolume* vol = new Trk::TrackingVolume(*volume, transform);
339  volOrder.push_back(std::shared_ptr<TrackingVolume>(vol));
340  }
341  const Trk::NavBinnedArray1D<Trk::TrackingVolume>* confVols =
342  dynamic_cast<const Trk::NavBinnedArray1D<Trk::TrackingVolume>*>(
343  confinedVolumes);
344  if (confVols)
345  m_confinedVolumes = std::make_unique<Trk::NavBinnedArray1D<Trk::TrackingVolume>>(
346  *confVols,
347  std::vector<std::shared_ptr<Trk::TrackingVolume>>(volOrder),
348  transform);
349  }
350 
351  // confined unordered volumes
352  Trk::ArraySpan<const Trk::TrackingVolume* const> confinedDenseVolumes =
353  trVol.confinedDenseVolumes();
354  if (!confinedDenseVolumes.empty()) {
355  std::vector<Trk::TrackingVolume*> newVol;
356  newVol.reserve(confinedDenseVolumes.size());
357  // retrieve array objects and apply the transform
358  for (const auto *confinedDenseVolume : confinedDenseVolumes) {
359  Trk::TrackingVolume* vol = new Trk::TrackingVolume(*confinedDenseVolume, transform);
360  newVol.push_back(vol);
361  }
362  m_confinedDenseVolumes = std::make_unique<const std::vector<Trk::TrackingVolume*>>(newVol);
363  }
364 }

◆ ~TrackingVolume()

Trk::TrackingVolume::~TrackingVolume ( )
overridevirtual

Destructor.

Definition at line 366 of file TrackingVolume.cxx.

367 {
368  //We need to clean the elements we own from the vectors
369  if (m_confinedDenseVolumes) {
370  for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
371  delete confinedDenseVolume;
372  }
373  }
374  if (m_confinedArbitraryLayers) {
375  for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
376  delete confinedArbitraryLayer;
377  }
378  }
379 }

◆ TrackingVolume() [14/14]

Trk::TrackingVolume::TrackingVolume ( const TrackingVolume &  )
privatedelete

Forbidden copy constructor.

Member Function Documentation

◆ addMaterial()

void Trk::TrackingVolume::addMaterial ( const Material &  mat,
float  fact = 1. 
)

add Material

Definition at line 736 of file TrackingVolume.cxx.

737 {
738  // assume the scaling factor refers to the volume scaling
739  float flin = pow(fact, 0.33);
740  // average X0
741  double invX0 = X0 > 0. ? 1. / X0 : 0.;
742  double sum_invX0 = invX0 + flin / mprop.X0;
743  X0 = 1. / sum_invX0;
744  // average L0
745  double invL0 = L0 > 0. ? 1. / L0 : 0.;
746  double sum_invL0 = invL0 + flin / mprop.L0;
747  L0 = 1. / sum_invL0;
748  // add density
749  float rho1 = rho;
750  rho += fact * mprop.rho;
751  // averageZ
752  float n1 = Z > 0. ? rho1 / Z : 0.;
753  float n2 = fact * mprop.rho / mprop.Z;
754  Z = rho / (n1 + n2);
755  // averageA
756  n1 = A > 0. ? rho1 / A : 0.;
757  n2 = fact * mprop.rho / mprop.A;
758  A = rho / (n1 + n2);
759  // zOverAtimesRho
760  zOaTr = Z / A * rho;
761  // mean energy loss (linear scaling)
762  dEdX += flin * mprop.dEdX;
763 }

◆ assocDetachedSubVolumes()

std::vector< const Trk::DetachedTrackingVolume * > Trk::TrackingVolume::assocDetachedSubVolumes ( const Amg::Vector3D &  gp,
double  tol 
) const

Return the associated detached subvolumes.

Definition at line 624 of file TrackingVolume.cxx.

626 {
627  auto currVols = std::vector<const Trk::DetachedTrackingVolume*>();
628 
629  Trk::ArraySpan<const Trk::DetachedTrackingVolume* const> detVols =
630  confinedDetachedVolumes();
631  if (!detVols.empty()) {
632  for (const auto *detVol : detVols) {
633  if (detVol->trackingVolume()->inside(gp, tol)){
634  currVols.push_back(detVol);
635  }
636  }
637  }
638  return currVols;
639 }

◆ associatedLayer() [1/2]

Trk::Layer * Trk::TrackingVolume::associatedLayer ( const Amg::Vector3D &  gp)

Definition at line 400 of file TrackingVolume.cxx.

401 {
402  // confined layers
403  if (m_confinedLayers){
404  return (confinedLayers()->object(gp));
405  }
406  // confined arbitrary
407  if (m_confinedArbitraryLayers) {
408  for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
409  if (confinedArbitraryLayer->isOnLayer(gp)){
410  return confinedArbitraryLayer;
411  }
412  }
413  }
414  return nullptr;
415 }

◆ associatedLayer() [2/2]

const Trk::Layer * Trk::TrackingVolume::associatedLayer ( const Amg::Vector3D &  gp) const

Return the associated Layer.

Definition at line 382 of file TrackingVolume.cxx.

383 {
384  // confined layers
385  if (m_confinedLayers){
386  return (confinedLayers()->object(gp));
387  }
388  // confined arbitrary
389  if (m_confinedArbitraryLayers) {
390  for (auto* confinedArbitraryLayer : *m_confinedArbitraryLayers){
391  if (confinedArbitraryLayer->isOnLayer(gp)){
392  return confinedArbitraryLayer;
393  }
394  }
395  }
396  return nullptr;
397 }

◆ associatedSubVolume() [1/2]

Trk::TrackingVolume * Trk::TrackingVolume::associatedSubVolume ( const Amg::Vector3D &  gp)

Definition at line 556 of file TrackingVolume.cxx.

557 {
558  if (m_confinedVolumes){
559  return (m_confinedVolumes->object(gp));
560  }
561 
562  if (m_confinedDetachedVolumes) {
563  for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
564  if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
565  return confinedDetachedVolume->trackingVolume();
566  }
567  }
568  }
569 
570  if (m_confinedDenseVolumes) {
571  for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
572  if (confinedDenseVolume->inside(gp, 0.001)){
573  return confinedDenseVolume;
574  }
575  }
576  }
577 
578  return this;
579 }

◆ associatedSubVolume() [2/2]

const Trk::TrackingVolume * Trk::TrackingVolume::associatedSubVolume ( const Amg::Vector3D &  gp) const

Return the associated sub Volume, returns THIS if no subVolume exists.

Definition at line 530 of file TrackingVolume.cxx.

531 {
532  if (m_confinedVolumes){
533  return (m_confinedVolumes->object(gp));
534  }
535 
536  if (m_confinedDetachedVolumes) {
537  for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
538  if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
539  return confinedDetachedVolume->trackingVolume();
540  }
541  }
542  }
543 
544  if (m_confinedDenseVolumes) {
545  for (auto *confinedDenseVolume : *m_confinedDenseVolumes){
546  if (confinedDenseVolume->inside(gp, 0.001)){
547  return confinedDenseVolume;
548  }
549  }
550  }
551 
552  return this;
553 }

◆ averageZ()

float Trk::Material::averageZ ( ) const
inlineinherited

Definition at line 228 of file Material.h.

228 { return (*this).Z; }

◆ boundarySurface()

const Trk::BoundarySurface< Trk::TrackingVolume > * Trk::TrackingVolume::boundarySurface ( const ObjectAccessor::value_type &  oa) const

Get the BoundarySurface to the appointed Accessor state.

Definition at line 822 of file TrackingVolume.cxx.

823 {
824  return (std::as_const(m_boundarySurfaces)[oa]).get();
825 }

◆ boundarySurfaceAccessor()

Trk::ObjectAccessor Trk::Volume::boundarySurfaceAccessor ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  mom,
bool  forceInside = false 
) const
inherited

Provide accessor for BoundarySurfaces.

Definition at line 82 of file Volume.cxx.

86 {
87  if (!m_transform) {
88  return Trk::ObjectAccessor(
89  volumeBounds().boundarySurfaceAccessor(gp, dir, forceInside));
90  }
91  return Trk::ObjectAccessor(volumeBounds().boundarySurfaceAccessor(
92  transform().inverse() * gp, dir, forceInside));
93 }

◆ boundarySurfaces() [1/2]

std::vector< std::shared_ptr< Trk::BoundarySurface< Trk::TrackingVolume > > > & Trk::TrackingVolume::boundarySurfaces ( )

Method to return the BoundarySurfaces.

Definition at line 809 of file TrackingVolume.cxx.

810 {
811  return m_boundarySurfaces;
812 }

◆ boundarySurfaces() [2/2]

Trk::ConstSharedPtrSpan< Trk::BoundarySurface< Trk::TrackingVolume > > Trk::TrackingVolume::boundarySurfaces ( ) const

Definition at line 815 of file TrackingVolume.cxx.

816 {
817  return Trk::ConstSharedPtrSpan<Trk::BoundarySurface<Trk::TrackingVolume>>(
818  m_boundarySurfaces);
819 }

◆ boundarySurfacesOrdered()

template<class T >
std::vector<BoundaryIntersection<T> > Trk::TrackingVolume::boundarySurfacesOrdered ( const T &  parameters,
PropDirection  pDir = alongMomentum,
bool  startOffBoundary = false 
) const

Returns the boundary surfaces ordered in probability to hit them based on straight line intersection.

◆ center()

const Amg::Vector3D & Trk::Volume::center ( ) const
inlineinherited

returns the center of the volume

Definition at line 90 of file Volume.h.

91  {
92  return m_center;
93  }

◆ checkoutConfinedLayers()

const Trk::LayerArray * Trk::TrackingVolume::checkoutConfinedLayers ( ) const

Return the subLayerarray including the ownership.

Definition at line 1003 of file TrackingVolume.cxx.

1004 {
1005  const Trk::LayerArray* checkoutLayers = m_confinedLayers.get();
1006  return checkoutLayers;
1007 }

◆ clone()

Trk::Volume * Trk::Volume::clone ( ) const
virtualinherited

polymorpic deep copy

Definition at line 60 of file Volume.cxx.

61 {
62  return new Trk::Volume(*this);
63 }

◆ closest()

const Trk::Layer * Trk::TrackingVolume::closest ( const Amg::Vector3D &  pos,
const Amg::Vector3D &  dir,
const Layer &  first,
const Layer &  second 
)
staticprivate

Helper method - find closest of two layers.

Definition at line 1046 of file TrackingVolume.cxx.

1050 {
1051  // use the distance solution for assigning the layer
1052  Trk::DistanceSolution distSolToPrevious =
1053  first.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
1054  Trk::DistanceSolution distSolToNext =
1055  second.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
1056  // find out which one
1057  return (distSolToPrevious.absClosest() < distSolToNext.absClosest()
1058  ? &first
1059  : &second);
1060 }

◆ closestMaterialLayer()

Trk::LayerIntersection< Amg::Vector3D > Trk::TrackingVolume::closestMaterialLayer ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir,
PropDirection  pDir = alongMomentum,
const BoundaryCheck &  bchk = true 
) const

Return the closest layer with material description.

  • it assumes to be on lowest navigation level
  • does not step down to eventually confined TrackingVolumes
  • navigates to the next trackign volume IF PropDirection == mappingMode

Definition at line 445 of file TrackingVolume.cxx.

449 {
450  // the layer candidates to check
451  std::vector<const Layer*> layerCandidates;
452 
453  // ---------------- BOUNDARY LAYER SECTION (only for mapping) ----------
454  if (pDir == mappingMode) {
455  const auto& bSurfaces = boundarySurfaces();
456  for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
457  if (bSurfaces[ib]->surfaceRepresentation().materialLayer()){
458  layerCandidates.push_back(bSurfaces[ib]->surfaceRepresentation().materialLayer());
459  }
460  }
461  }
462  // ---------------- CONFINED LAYER SECTION --------------
463  if (m_confinedLayers) {
464  // the associated layer
465  const Trk::Layer* assocLayer = associatedLayer(gp);
466  const Trk::Layer* previousMatLayer = nullptr;
467  const Trk::Layer* nextMatLayer = nullptr;
468  // if the associated layer is a navigation layer - get the previous and next
469  // from this one
470  const Trk::NavigationLayer* navLayer =
471  dynamic_cast<const Trk::NavigationLayer*>(assocLayer);
472  if (navLayer) {
473  // get previous / next
474  previousMatLayer = navLayer->previousLayer();
475  nextMatLayer = navLayer->nextLayer();
476  if (previousMatLayer){
477  layerCandidates.push_back(previousMatLayer);
478  }
479  if (nextMatLayer){
480  layerCandidates.push_back(nextMatLayer);
481  }
482  } else{
483  layerCandidates.push_back(assocLayer);
484  }
485  }
486  // --- solve for the layer candidates ---------------------
487  //
488  Trk::Intersection laySurfIntersection(Amg::Vector3D(0., 0., 0.), 10e10, false);
489  // layer candidates found - continue
490  if (!layerCandidates.empty()) {
491  const Layer* cLayer = nullptr;
492  // iterate through and chose
493  for (auto& lcIter : layerCandidates) {
494  // only the forceFwd solution is possible here
495  bool forceDir = (pDir == alongMomentum || pDir == oppositeMomentum);
496  double dirScalor = (pDir == oppositeMomentum) ? -1. : 1.;
497  // get the intersection soltuion
498  Trk::Intersection sfI =
499  (*lcIter).surfaceRepresentation().straightLineIntersection(
500  gp, dirScalor * dir, forceDir, bchk);
501  if (sfI.valid &&
502  (sfI.pathLength * sfI.pathLength) <
503  (laySurfIntersection.pathLength * laySurfIntersection.pathLength)) {
504  laySurfIntersection = sfI;
505  cLayer = lcIter;
506  }
507  }
508  // now return the pair: in case of a valid intersection, or if no mapping
509  // mode is chosen
510  if (cLayer){
511  return Trk::LayerIntersection<Amg::Vector3D>(
512  laySurfIntersection,
513  cLayer,
514  &(cLayer->surfaceRepresentation()),
515  nullptr,
516  pDir);
517  }
518  }
519  // mapping mode chosen, but no valid intersection yet
520  const Trk::TrackingVolume* nVolume = nextVolume(gp, dir, pDir);
521 
522  // forward the next Volume solution or a 0 solution
523  return (nVolume && nVolume != this)
524  ? nVolume->closestMaterialLayer(gp, dir, pDir, bchk)
525  : Trk::LayerIntersection<Amg::Vector3D>(
526  laySurfIntersection, nullptr, nullptr, nullptr, pDir);
527 }

◆ colorCode()

unsigned int Trk::TrackingVolume::colorCode ( ) const

Get the color code.

◆ compactify()

void Trk::TrackingVolume::compactify ( size_t &  rSurfaces,
size_t &  tSurfaces 
)
private

compactify the memory usage in the event by setting ownership to TackingGeometry the referenced types are the number of registered surfaces & total surfaces

Definition at line 1131 of file TrackingVolume.cxx.

1132 {
1133  // confined 'ordered' layers
1134  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1135  if (confLayers) {
1136  std::span<Trk::Layer* const> layers = confLayers->arrayObjects();
1137  for (const auto& clayIter : layers) {
1138  if (&(*clayIter) != nullptr){
1139  clayIter->compactify(cSurfaces, tSurfaces);
1140  }
1141  else{
1142  std::cout << "WARNING: Attempt to compactify nullptr layer in volume : "
1143  << volumeName() << std::endl;
1144  }
1145  }
1146  }
1147  // confined 'unordered' layers
1148  Trk::ArraySpan<Trk::Layer* const> confArbLayers = confinedArbitraryLayers();
1149  if (!confArbLayers.empty()) {
1150  for (const auto& calayIter : confArbLayers) {
1151  if (calayIter != nullptr) {
1152  calayIter->compactify(cSurfaces, tSurfaces);
1153  } else {
1154  std::cout << "WARNING: Attempt to compactify nullptr layer."
1155  << std::endl;
1156  }
1157  }
1158  }
1159  // confined volumes
1160  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1161  if (confVolumes) {
1162  std::span<Trk::TrackingVolume* const> volumes =
1163  confVolumes->arrayObjects();
1164  for (const auto& cVolumesIter : volumes) {
1165  cVolumesIter->compactify(cSurfaces, tSurfaces);
1166  }
1167  }
1168  // confined unordered volumes
1169  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes = confinedDenseVolumes();
1170  if (!confDenseVolumes.empty()){
1171  for (const auto& cVolumesIter : (confDenseVolumes)) {
1172  cVolumesIter->compactify(cSurfaces, tSurfaces);
1173  }
1174  }
1175 
1176  // detached volumes if any
1177  if (m_confinedDetachedVolumes){
1178  for (const auto& cdVolumesIter : (*m_confinedDetachedVolumes)) {
1179  cdVolumesIter->compactify(cSurfaces, tSurfaces);
1180  }
1181  }
1182 }

◆ confinedArbitraryLayers() [1/2]

ArraySpan<Layer* const> Trk::TrackingVolume::confinedArbitraryLayers ( )

Return the confined subLayer array.

Layers are not const

◆ confinedArbitraryLayers() [2/2]

ArraySpan<Layer const * const> Trk::TrackingVolume::confinedArbitraryLayers ( ) const

Return the confined subLayer array.

◆ confinedDenseVolumes() [1/2]

ArraySpan<TrackingVolume * const> Trk::TrackingVolume::confinedDenseVolumes ( )

◆ confinedDenseVolumes() [2/2]

ArraySpan<TrackingVolume const * const> Trk::TrackingVolume::confinedDenseVolumes ( ) const

Return unordered subVolumes - not the ownership.

◆ confinedDetachedVolumes() [1/2]

ArraySpan<DetachedTrackingVolume * const> Trk::TrackingVolume::confinedDetachedVolumes ( )

◆ confinedDetachedVolumes() [2/2]

ArraySpan<DetachedTrackingVolume const * const> Trk::TrackingVolume::confinedDetachedVolumes ( ) const

Return detached subVolumes - not the ownership.

◆ confinedLayers() [1/2]

LayerArray* Trk::TrackingVolume::confinedLayers ( )

Return the subLayer array.

◆ confinedLayers() [2/2]

const LayerArray* Trk::TrackingVolume::confinedLayers ( ) const

Return the subLayer array.

◆ confinedVolumes() [1/2]

TrackingVolumeArray* Trk::TrackingVolume::confinedVolumes ( )

Return the subLayer array.

◆ confinedVolumes() [2/2]

const TrackingVolumeArray* Trk::TrackingVolume::confinedVolumes ( ) const

Return the subLayer array.

◆ createBoundarySurfaces()

void Trk::TrackingVolume::createBoundarySurfaces ( )
private

Create Boundary Surface.

Definition at line 828 of file TrackingVolume.cxx.

829 {
830  // prepare the BoundarySurfaces
831  m_boundarySurfaces =
832  std::vector<std::shared_ptr<Trk::BoundarySurface<Trk::TrackingVolume>>>();
833  // transform Surfaces To BoundarySurfaces
834  std::vector<std::unique_ptr<Trk::Surface>> surfaces =
835  Trk::Volume::volumeBounds().decomposeToSurfaces(transform());
836  auto surfIter = surfaces.begin();
837 
838  // counter to flip the inner/outer position for Cylinders
839  unsigned int sfCounter = 0;
840  unsigned int sfNumber = surfaces.size();
841 
842  // memory optimisation
843  m_boundarySurfaces.reserve(sfNumber + 1);
844 
845  // identify Subtracted/CombinedVolumes
846  const Trk::SubtractedVolumeBounds* subtrVol =
847  dynamic_cast<const Trk::SubtractedVolumeBounds*>(
848  &(Trk::Volume::volumeBounds()));
849  const Trk::CombinedVolumeBounds* combVol =
850  dynamic_cast<const Trk::CombinedVolumeBounds*>(
851  &(Trk::Volume::volumeBounds()));
852  bool subtr = (subtrVol) ? 1 : 0;
853  bool comb = (combVol) ? 1 : 0;
854 
855  if (!subtr && !comb) {
856  const Trk::SimplePolygonBrepVolumeBounds* spbVol =
857  dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
858  &(Trk::Volume::volumeBounds()));
859 
860  for (; surfIter != surfaces.end(); ++surfIter) {
861  sfCounter++;
862 
863  Trk::TrackingVolume* in = this;
864  Trk::TrackingVolume* out = nullptr;
865 
866  // ST update: subtracted surfaces may appear in 'simple' volumes
867  // (SimplePolygonBrep...)
868  const Trk::SubtractedPlaneSurface* spsf =
869  dynamic_cast<const Trk::SubtractedPlaneSurface*>((*surfIter).get());
870  const Trk::PlaneSurface* psf =
871  dynamic_cast<const Trk::PlaneSurface*>((*surfIter).get());
872  if (spsf) {
873  if (spbVol && sfCounter == 1) {
874  in = nullptr;
875  out = this;
876  }
877  m_boundarySurfaces.push_back(
878  std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
879  in, out, *spsf));
880  continue;
881  }
882  if (psf) {
883  m_boundarySurfaces.push_back(
884  std::make_shared<Trk::BoundaryPlaneSurface<Trk::TrackingVolume>>(in, out, *psf));
885  continue;
886  }
887 
888  const Trk::DiscSurface* dsf =
889  dynamic_cast<const Trk::DiscSurface*>((*surfIter).get());
890  if (dsf) {
891  m_boundarySurfaces.push_back(
892  std::make_shared<Trk::BoundaryDiscSurface<Trk::TrackingVolume>>(in, out, *dsf));
893  continue;
894  }
895 
896  const Trk::SubtractedCylinderSurface* scsf =
897  dynamic_cast<const Trk::SubtractedCylinderSurface*>((*surfIter).get());
898  const Trk::CylinderSurface* csf =
899  dynamic_cast<const Trk::CylinderSurface*>((*surfIter).get());
900  if (scsf) {
901  Trk::TrackingVolume* inner =
902  (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
903  Trk::TrackingVolume* outer = (inner) ? nullptr : this;
904  m_boundarySurfaces.push_back(
905  std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(inner, outer, *scsf));
906  continue;
907  }
908  if (csf) {
909  Trk::TrackingVolume* inner =
910  (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
911  Trk::TrackingVolume* outer = (inner) ? nullptr : this;
912  m_boundarySurfaces.push_back(
913  std::make_shared<Trk::BoundaryCylinderSurface<Trk::TrackingVolume>>(
914  inner, outer, *csf));
915  continue;
916  }
917  }
918 
919  } else {
920  const std::vector<bool> bOrient =
921  subtrVol ? subtrVol->boundsOrientation() : combVol->boundsOrientation();
922 
923  for (; surfIter != surfaces.end(); ++surfIter) {
924  Trk::TrackingVolume* in = bOrient[sfCounter] ? this : nullptr;
925  Trk::TrackingVolume* out = bOrient[sfCounter] ? nullptr : this;
926  sfCounter++;
927 
928  const Trk::SubtractedPlaneSurface* psf =
929  dynamic_cast<const Trk::SubtractedPlaneSurface*>((*surfIter).get());
930  if (psf) {
931  m_boundarySurfaces.push_back(
932  std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
933  in, out, *psf));
934  continue;
935  }
936 
937  const Trk::SubtractedCylinderSurface* csf =
938  dynamic_cast<const Trk::SubtractedCylinderSurface*>((*surfIter).get());
939  if (csf) {
940  m_boundarySurfaces.push_back(
941  std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(
942  in, out, *csf));
943  continue;
944  }
945  }
946  }
947 }

◆ createLayerAttemptsCalculator()

void Trk::TrackingVolume::createLayerAttemptsCalculator ( )
private

Create Layer Attempts Caluclator.

Definition at line 950 of file TrackingVolume.cxx.

951 {
952  // check whether there's a static array
953  if (m_confinedLayers) {
954  // BinUtility
955  const Trk::BinUtility* binUtility = m_confinedLayers->binUtility();
956  if (binUtility) {
957  if (binUtility->binningValue() == Trk::binR){
958  m_layerAttemptsCalculator = std::make_unique<Trk::CylinderLayerAttemptsCalculator>(1, 5);
959  }
960  if (binUtility->binningValue() == Trk::binZ){
961  m_layerAttemptsCalculator = std::make_unique<Trk::DiscLayerAttemptsCalculator>(1, 5);
962  }
963  }
964  }
965 }

◆ entryLayer()

const Layer* Trk::TrackingVolume::entryLayer ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir 
) const

Return the entry Layer to a TrackingVolume depending on the entry point.

◆ exitLayer()

const Layer* Trk::TrackingVolume::exitLayer ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir 
) const

Return the exit Layer from a TrackingVolume.

◆ geometrySignature()

GeometrySignature Trk::TrackingVolume::geometrySignature ( ) const

return the Signature

◆ geometryType()

GeometryType Trk::TrackingVolume::geometryType ( ) const

return the Signature

◆ getMotherVolume()

const TrackingVolume* Trk::TrackingVolume::getMotherVolume ( ) const

Return the MotherVolume - if it exists.

◆ glueVolumesDescriptor() [1/2]

Trk::GlueVolumesDescriptor & Trk::TrackingVolume::glueVolumesDescriptor ( )

Definition at line 1016 of file TrackingVolume.cxx.

1017 {
1018  if (!m_outsideGlueVolumes) {
1019  m_outsideGlueVolumes.store(std::make_unique<Trk::GlueVolumesDescriptor>());
1020  }
1021  return (*m_outsideGlueVolumes);
1022 }

◆ glueVolumesDescriptor() [2/2]

const Trk::GlueVolumesDescriptor & Trk::TrackingVolume::glueVolumesDescriptor ( ) const

Definition at line 1025 of file TrackingVolume.cxx.

1026 {
1027  if (!m_outsideGlueVolumes) {
1028  m_outsideGlueVolumes.set(std::make_unique<Trk::GlueVolumesDescriptor>());
1029  }
1030  return (*m_outsideGlueVolumes);
1031 }

◆ indexContainedMaterialLayers()

void Trk::TrackingVolume::indexContainedMaterialLayers ( GeometrySignature  geoSig,
int &  offset 
)
private

reIndex the material layers of the TrackingVolume

Definition at line 689 of file TrackingVolume.cxx.

691 {
692  // the offset gets increased internally
693  // the static layers first and check if they have surfaces with material
694  // layers that need index
695  if (m_confinedLayers) {
696  std::span<Trk::Layer * const> layers = confinedLayers()->arrayObjects();
697  for (Trk::Layer* layerIter : layers) {
698  // only index the material layers & only those that have not yet been
699  // singed
700  if (layerIter) {
701  Trk::SurfaceArray* surfArray = layerIter->surfaceArray();
702  if (surfArray) {
703  std::span<Trk::Surface * const> layerSurfaces = surfArray->arrayObjects();
704  // loop over the surfaces - there can be 0 entries
705  for (Trk::Surface* const laySurf : layerSurfaces) {
706  Trk::MaterialLayer* materialLayer = laySurf ? laySurf->materialLayer() : nullptr;
707  if (materialLayer && materialLayer->layerIndex().value() < 0) {
708  // sign only those with material properties - rest goes to 0
709  Trk::LayerIndex layIndex =
710  materialLayer->layerMaterialProperties()
711  ? Trk::LayerIndex(int(geoSig) *
712  TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT +
713  (++offset))
714  : Trk::LayerIndex(0);
715  // now register the index
716  materialLayer->registerLayerIndex(layIndex);
717  }
718  }
719  }
720  }
721  }
722  }
723 
724  // step down the hierarchy to the contained volumes and index those
725  // ------------------------
726  if (confinedVolumes()) {
727  std::span<Trk::TrackingVolume * const> volumes = confinedVolumes()->arrayObjects();
728  for (Trk::TrackingVolume* volumesIter : volumes) {
729  if (volumesIter)
730  volumesIter->indexContainedMaterialLayers(geoSig, offset);
731  }
732  }
733 }

◆ indexContainedStaticLayers()

void Trk::TrackingVolume::indexContainedStaticLayers ( GeometrySignature  geoSig,
int &  offset 
)
private

reIndex the static layers of the TrackingVolume

Definition at line 642 of file TrackingVolume.cxx.

644 {
645  // the offset gets increased internally
646  // the static layers first
647  // ------------------------------------------------------------------
648  if (m_confinedLayers) {
649  std::span<Trk::Layer* const> layers = confinedLayers()->arrayObjects();
650  for (Trk::Layer* layerptr : layers) {
651  // only index the material layers & only those that have not yet been
652  // singed
653  if (layerptr && layerptr->layerIndex().value() < 0) {
654  // sign only those with material properties - rest goes to 0
655  Trk::LayerIndex layIndex =
656  layerptr->layerMaterialProperties()
657  ? Trk::LayerIndex(
658  int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset))
659  : Trk::LayerIndex(0);
660  // now register the index
661  layerptr->registerLayerIndex(layIndex);
662  }
663  }
664  }
665 
666  // the boundary surface layer
667  auto& bSurfaces = boundarySurfaces();
668  for (const auto& bsIter : bSurfaces) {
669  Trk::MaterialLayer* mLayer = bsIter->surfaceRepresentation().materialLayer();
670  if (mLayer && mLayer->layerIndex().value() < 0.) {
671  Trk::LayerIndex layIndex = Trk::LayerIndex(
672  int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset));
673  mLayer->registerLayerIndex(layIndex);
674  }
675  }
676 
677  // step down the hierarchy to the contained volumes and index those
678  // ------------------------
679  if (confinedVolumes()) {
680  std::span<Trk::TrackingVolume* const > volumes = confinedVolumes()->arrayObjects();
681  for (const auto& volumesIter : volumes) {
682  if (volumesIter)
683  volumesIter->indexContainedStaticLayers(geoSig, offset);
684  }
685  }
686 }

◆ inside()

ATH_FLATTEN bool Trk::Volume::inside ( const Amg::Vector3D &  gp,
double  tol = 0. 
) const
inherited

Inside() method for checks.

Definition at line 72 of file Volume.cxx.

73 {
74  if (!m_transform) {
75  return (volumeBounds()).inside(gp, tol);
76  }
77  Amg::Vector3D posInVolFrame((transform().inverse()) * gp);
78  return (volumeBounds()).inside(posInVolFrame, tol);
79 }

◆ interlinkLayers()

void Trk::TrackingVolume::interlinkLayers ( )
private

Register Next - Previous for Layers, set volumelink.

Definition at line 967 of file TrackingVolume.cxx.

968 {
969  if (m_confinedLayers) {
970  std::span<Trk::Layer* const> layers = m_confinedLayers->arrayObjects();
971  // forward loop
972  const Trk::Layer* lastLayer = nullptr;
973  std::span<Trk::Layer* const>::iterator layerIter = layers.begin();
974  for (; layerIter != layers.end(); ++layerIter) {
975  if (*layerIter) {
976  // register the layers
977  (**layerIter).setBinUtility(confinedLayers()->binUtility()
978  ? confinedLayers()->binUtility()
979  : nullptr);
980  (**layerIter).setPreviousLayer(lastLayer);
981  // register the volume
982  (**layerIter).encloseTrackingVolume(*this);
983  }
984  lastLayer = (*layerIter);
985  }
986  // backward loop
987  lastLayer = nullptr;
988  layerIter = layers.end();
989  --layerIter;
990  for (;; --layerIter) {
991  if (*layerIter) {
992  (**layerIter).setNextLayer(lastLayer);
993  }
994  lastLayer = (*layerIter);
995  if (layerIter == layers.begin()) {
996  break;
997  }
998  }
999  }
1000 }

◆ isAlignable()

virtual bool Trk::TrackingVolume::isAlignable ( ) const
virtual

Reimplemented in Trk::AlignableTrackingVolume.

◆ layerAttempts()

unsigned int Trk::TrackingVolume::layerAttempts ( BoundarySurfaceFace  exitFace) const

Layer attempts - as provided by the LayerAttemptCreator.

◆ materialLayersOrdered()

template<class T >
std::vector<LayerIntersection<T> > Trk::TrackingVolume::materialLayersOrdered ( const Layer *  sLayer,
const Layer *  eLayer,
const T &  parameters,
PropDirection  pDir = alongMomentum,
const BoundaryCheck &  bchk = true,
bool  resolveSubSurfaces = false 
) const

Return the material layers ordered based on straight line intersections:

  • startLayer and endLayer are included in the list

◆ maxLayerAttempts()

unsigned int Trk::TrackingVolume::maxLayerAttempts ( ) const

Layer attempts - as provided by the LayerAttemptCreator.

◆ moveTV()

void Trk::TrackingVolume::moveTV ( Amg::Transform3D &  transform)
private

move the Tracking Volume

Definition at line 1063 of file TrackingVolume.cxx.

1064 {
1065 
1066  this->moveVolume(transform);
1067 
1068  // confined 'ordered' layers
1069  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1070  if (confLayers)
1071  for (Trk::Layer* clayIter : confLayers->arrayObjects()){
1072  clayIter->moveLayer(transform);
1073  }
1074 
1075  // confined 'unordered' layers
1076  Trk::ArraySpan<Trk::Layer* const> confArbLayers =
1077  confinedArbitraryLayers();
1078  if (!confArbLayers.empty()){
1079  for (Trk::Layer* calayIter : confArbLayers){
1080  calayIter->moveLayer(transform);
1081  }
1082  }
1083 
1084  // confined volumes
1085  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1086  if (confVolumes){
1087  // retrieve array objects and apply the transform
1088  for (Trk::TrackingVolume* cVolumesIter : confVolumes->arrayObjects()){
1089  (cVolumesIter)->moveTV(transform);
1090  }
1091  }
1092 
1093  // confined unordered volumes
1094  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes = confinedDenseVolumes();
1095  if (!confDenseVolumes.empty())
1096  // retrieve array objects and apply the transform
1097  for (Trk::TrackingVolume* cVolumesIter : confDenseVolumes){
1098  cVolumesIter->moveTV(transform);
1099  }
1100 }

◆ moveVolume()

void Trk::TrackingVolume::moveVolume ( Amg::Transform3D &  shift)

move Volume

Definition at line 1034 of file TrackingVolume.cxx.

1035 {
1036  if (m_transform) {
1037  Amg::Transform3D transf = shift * (*m_transform);
1038  this->m_transform = std::make_unique<Amg::Transform3D>(transf);
1039  } else {
1040  this->m_transform = std::make_unique<Amg::Transform3D>(shift);
1041  }
1042  this->m_center = (m_transform->translation());
1043 }

◆ nextLayer()

const Trk::Layer * Trk::TrackingVolume::nextLayer ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  mom,
bool  asres = true,
bool  skipNavLayer = false 
) const

Return the next Layer if existing, NULL if no next layer corresponds.

Definition at line 418 of file TrackingVolume.cxx.

422 {
423  const Trk::Layer* nextLayer = nullptr;
424  if (m_confinedLayers){
425  nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
426  }
427  // forward it in this case
428  if (!skipNavLayer){
429  return nextLayer;
430  }
431  // if only material or layers
432  if (nextLayer &&
433  (nextLayer->layerMaterialProperties() || nextLayer->surfaceArray())){
434  return nextLayer;
435  }
436  // try to get the next layer that has either material or sub surfaces
437  while (nextLayer && (!(nextLayer->layerMaterialProperties()) &&
438  !(nextLayer->surfaceArray()))){
439  nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
440  }
441  return nextLayer;
442 }

◆ nextSubVolume()

const Trk::TrackingVolume * Trk::TrackingVolume::nextSubVolume ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir 
) const

Return the next sub Volume if existing, returns THIS if no subVolume exists.

Definition at line 614 of file TrackingVolume.cxx.

616 {
617  if (m_confinedVolumes){
618  return (m_confinedVolumes->nextObject(gp, mom));
619  }
620  return this;
621 }

◆ nextVolume()

const Trk::TrackingVolume * Trk::TrackingVolume::nextVolume ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir,
Trk::PropDirection  pDir = alongMomentum 
) const

Return the next volume along the navigation stream.

Definition at line 583 of file TrackingVolume.cxx.

586 {
587  // get the boundary surfaces & intersect them
588  const Trk::TrackingVolume* nVolume = nullptr;
589  // fix the direction once
590  bool forceDir = (pDir == Trk::alongMomentum || pDir == Trk::oppositeMomentum);
591  double dirScalor = (pDir == Trk::oppositeMomentum) ? -1. : 1.;
592  Amg::Vector3D cDir = dirScalor * dir;
593  double pathLength = 10e10;
594  // now loop through the and find the closest
595  const auto& bSurfaces = boundarySurfaces();
596  for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
597  // get the intersection soltuion
598  Trk::Intersection sfI =
599  bSurfaces[ib]->surfaceRepresentation().straightLineIntersection(
600  gp, cDir, forceDir, true);
601  if (sfI.valid &&
602  (sfI.pathLength * sfI.pathLength) < (pathLength * pathLength)) {
603  // assign the next Volume
604  Trk::PropDirection attachedDir =
605  sfI.pathLength > 0. ? Trk::alongMomentum : Trk::oppositeMomentum;
606  pathLength = sfI.pathLength;
607  nVolume = bSurfaces[ib]->attachedVolume(gp, cDir, attachedDir);
608  }
609  }
610  return nVolume;
611 }

◆ onVolumeBoundary()

template<class T >
bool Trk::TrackingVolume::onVolumeBoundary ( const T &  pars) const

show if you are on a boundary surface

◆ operator=()

TrackingVolume& Trk::TrackingVolume::operator= ( const TrackingVolume &  )
privatedelete

Forbid assignment.

mother volume of this volume view ptr

◆ registerColorCode()

void Trk::TrackingVolume::registerColorCode ( unsigned int  icolor)

Register the color code.

◆ registerOutsideGlueVolumes()

void Trk::TrackingVolume::registerOutsideGlueVolumes ( Trk::GlueVolumesDescriptor *  gvd)

Register the outside glue volumes - ordering is in the TrackingVolume Frame:

  • negativeFaceXY
  • (faces YZ, ZY, radial faces)
  • positiveFaceXY

Definition at line 1010 of file TrackingVolume.cxx.

1011 {
1012  m_outsideGlueVolumes.store(std::unique_ptr<Trk::GlueVolumesDescriptor>(gvd));
1013 }

◆ scale()

std::unique_ptr< Material > Trk::Material::scale ( float  sf) const
inlineinherited

scaling method

Definition at line 240 of file Material.h.

240  {
241  // Tell clang to optimize assuming that FP exceptions can trap.
242  // Otherwise, it can vectorize the division, which can lead to
243  // spurious division-by-zero traps from unused vector lanes.
244  CXXUTILS_TRAPPING_FP;
245  return std::make_unique<Material>(X0 / sf, L0 / sf, sf * A, sf * Z, sf * rho);
246 }

◆ screenDump()

void Trk::TrackingVolume::screenDump ( MsgStream &  msg) const

Definition at line 1185 of file TrackingVolume.cxx.

1186 {
1187  msg << "[[ Trk::TrackingVolume ]] called: " << volumeName() << std::endl;
1188  msg << '\t' << '\t' << "# position (x,y,z) : " << center().x() << ", "
1189  << center().y() << ", " << center().z() << std::endl;
1190  msg << '\t' << '\t' << "# bounds : " << volumeBounds() << endmsg;
1191 }

◆ setMotherVolume()

void Trk::TrackingVolume::setMotherVolume ( const TrackingVolume *  mvol)

set the MotherVolume

◆ sign()

void Trk::TrackingVolume::sign ( GeometrySignature  signat,
GeometryType  gtype = Static 
)

sign the volume - the geometry builder has to do that

Definition at line 766 of file TrackingVolume.cxx.

768 {
769  // never overwrite what is already signed, that's a crime
770  if (m_geometrySignature == Trk::Unsigned) {
771  m_geometrySignature = geosign;
772  }
773  m_geometryType = geotype;
774 
775  // confined volumes
776  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
777  if (confVolumes) {
778  std::span<Trk::TrackingVolume* const> volumes =
779  confVolumes->arrayObjects();
780  for (const auto& volumesIter : volumes){
781  if (volumesIter){
782  volumesIter->sign(geosign, geotype);
783  }
784  }
785  }
786  // same procedure for the detached volumes
787  Trk::ArraySpan<Trk::DetachedTrackingVolume* const> confDetachedVolumes =
788  confinedDetachedVolumes();
789  if (!confDetachedVolumes.empty()) {
790  for (const auto& volumesIter : confDetachedVolumes) {
791  if (volumesIter) {
792  volumesIter->sign(geosign, geotype);
793  }
794  }
795  }
796  // confined dense volumes
797  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes =
798  confinedDenseVolumes();
799  if (!confDenseVolumes.empty()) {
800  for (const auto& volumesIter : confDenseVolumes) {
801  if (volumesIter) {
802  volumesIter->sign(geosign, geotype);
803  }
804  }
805  }
806 }

◆ synchronizeLayers()

void Trk::TrackingVolume::synchronizeLayers ( MsgStream &  msgstream,
double  envelope = 1. 
)
private

method to synchronize the layers with potentially updated volume bounds:

  • adapts the layer dimensions to the new volumebounds + envelope
  • adapts entry layer position where necessary to the new volumebounds

Definition at line 1103 of file TrackingVolume.cxx.

1104 {
1105  // case a : Layers exist
1106  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1107  if (confLayers) {
1108  for (Trk::Layer* clay : confLayers->arrayObjects())
1109  if (clay) {
1110  if (clay->surfaceRepresentation().type() ==
1111  Trk::SurfaceType::Cylinder &&
1112  !(center().isApprox(clay->surfaceRepresentation().center()))) {
1113  clay->resizeAndRepositionLayer(volumeBounds(), center(), envelope);
1114  } else {
1115  clay->resizeLayer(volumeBounds(), envelope);
1116  }
1117  } else
1118  msgstream << MSG::WARNING
1119  << " ---> found 0 pointer to layer in Volume [ "
1120  << volumeName() << " ], indicates problem." << endmsg;
1121  }
1122  // case b : container volume -> step down
1123  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1124  if (confVolumes) {
1125  for (const auto& cVolumesIter : confVolumes->arrayObjects())
1126  cVolumesIter->synchronizeLayers(msgstream, envelope);
1127  }
1128 }

◆ toString()

std::string Trk::Material::toString ( ) const
inlineinherited

spit out as a string

Definition at line 231 of file Material.h.

231  {
232  std::ostringstream sout;
233  sout << std::setiosflags(std::ios::fixed) << std::setprecision(4);
234  sout << "(" << X0 << " | " << L0 << " | " << A << " | " << Z << " | " << rho
235  << ")";
236  return sout.str();
237  }

◆ transform()

const Amg::Transform3D & Trk::Volume::transform ( ) const
inlineinherited

Return methods for geometry transform.

Definition at line 83 of file Volume.h.

83  {
84  if (m_transform) {
85  return (*m_transform);
86  }
87  return Trk::s_idTransform;
88  }

◆ volumeBounds() [1/2]

VolumeBounds & Trk::Volume::volumeBounds ( )
inlineinherited

Definition at line 102 of file Volume.h.

103  {
104  return *(m_volumeBounds.get());
105  }

◆ volumeBounds() [2/2]

const VolumeBounds & Trk::Volume::volumeBounds ( ) const
inlineinherited

returns the volumeBounds()

Definition at line 96 of file Volume.h.

97  {
98  return *(m_volumeBounds.get());
99  }

◆ volumeName()

const std::string& Trk::TrackingVolume::volumeName ( ) const

Returns the VolumeName - for debug reason, might be depreciated later.

◆ x0()

float Trk::Material::x0 ( ) const
inlineinherited

Definition at line 227 of file Material.h.

227 { return (*this).X0; }

◆ zOverAtimesRho()

float Trk::Material::zOverAtimesRho ( ) const
inlineinherited

access to members

Definition at line 226 of file Material.h.

226 { return (*this).zOaTr; }

Friends And Related Function Documentation

◆ DetachedTrackingVolume

friend class DetachedTrackingVolume
friend

Give the DetachedTrackingVolume friend rights.

Definition at line 128 of file TrackingVolume.h.

◆ TrackingGeometry

friend class TrackingGeometry
friend

Give the TrackingGeometry friend rights.

Definition at line 125 of file TrackingVolume.h.

◆ TrackingVolumeManipulator

friend class TrackingVolumeManipulator
friend

The TrackingVolumeManipulator has to be a friend.

Definition at line 122 of file TrackingVolume.h.

Member Data Documentation

◆ A

float Trk::Material::A
inherited

Definition at line 122 of file Material.h.

◆ composition

MaterialComposition* Trk::Material::composition
inherited

Definition at line 127 of file Material.h.

◆ dEdX

float Trk::Material::dEdX
inherited

Definition at line 125 of file Material.h.

◆ L0

float Trk::Material::L0
inherited

Definition at line 121 of file Material.h.

◆ m_boundarySurfaces

std::vector<std::shared_ptr<BoundarySurface<TrackingVolume> > > Trk::TrackingVolume::m_boundarySurfaces {nullptr}
private

Definition at line 438 of file TrackingVolume.h.

◆ m_center

Amg::Vector3D Trk::Volume::m_center = Trk::s_origin
protectedinherited

center position of the surface

Definition at line 79 of file Volume.h.

◆ m_colorCode

unsigned int Trk::TrackingVolume::m_colorCode {20}
private

Color code for displaying.

Definition at line 458 of file TrackingVolume.h.

◆ m_confinedArbitraryLayers

std::unique_ptr<const std::vector<Layer*> > Trk::TrackingVolume::m_confinedArbitraryLayers {nullptr}
private

Definition at line 448 of file TrackingVolume.h.

◆ m_confinedDenseVolumes

std::unique_ptr<const std::vector<TrackingVolume*> > Trk::TrackingVolume::m_confinedDenseVolumes {nullptr}
private

Additionally, Unordered Layers inside the Volume (we own the elements)

Definition at line 446 of file TrackingVolume.h.

◆ m_confinedDetachedVolumes

std::unique_ptr<const std::vector<DetachedTrackingVolume*> > Trk::TrackingVolume::m_confinedDetachedVolumes {nullptr}
private

Additionally, Unordered subvolumes (we own the elements)

Definition at line 444 of file TrackingVolume.h.

◆ m_confinedLayers

std::unique_ptr<LayerArray> Trk::TrackingVolume::m_confinedLayers {nullptr}
private

Array of Volumes inside the Volume.

Definition at line 440 of file TrackingVolume.h.

◆ m_confinedVolumes

std::unique_ptr<TrackingVolumeArray> Trk::TrackingVolume::m_confinedVolumes {nullptr}
private

Detached subvolumes.

Note that we do not own the volumes/elements

Definition at line 442 of file TrackingVolume.h.

◆ m_geometrySignature

GeometrySignature Trk::TrackingVolume::m_geometrySignature {Trk::Unsigned}
private

Definition at line 456 of file TrackingVolume.h.

◆ m_geometryType

GeometryType Trk::TrackingVolume::m_geometryType {Trk::NumberOfGeometryTypes}
private

The Signature done by the GeometryBuilder.

Definition at line 454 of file TrackingVolume.h.

◆ m_layerAttemptsCalculator

std::unique_ptr<LayerAttemptsCalculator> Trk::TrackingVolume::m_layerAttemptsCalculator {nullptr}
private

defines how the Extrapolator propagates through this

Definition at line 452 of file TrackingVolume.h.

◆ m_motherVolume

const TrackingVolume* Trk::TrackingVolume::m_motherVolume {nullptr}
private

boundary Surfaces, they can be shared between volumes

Definition at line 436 of file TrackingVolume.h.

◆ m_name

std::string Trk::TrackingVolume::m_name {"undefined"}
private

Volume name for debug reasons.

Definition at line 457 of file TrackingVolume.h.

◆ m_outsideGlueVolumes

CxxUtils::CachedUniquePtrT<GlueVolumesDescriptor> Trk::TrackingVolume::m_outsideGlueVolumes {nullptr}
private

provided the number of layer attempts

Definition at line 450 of file TrackingVolume.h.

◆ m_transform

std::unique_ptr<Amg::Transform3D> Trk::Volume::m_transform = nullptr
protectedinherited

Transform3D (optional)

Definition at line 78 of file Volume.h.

◆ m_volumeBounds

std::shared_ptr<VolumeBounds> Trk::Volume::m_volumeBounds = nullptr
protectedinherited

the volumeBounds

Definition at line 80 of file Volume.h.

◆ rho

float Trk::Material::rho
inherited

Definition at line 124 of file Material.h.

◆ X0

float Trk::Material::X0
inherited

Definition at line 120 of file Material.h.

◆ Z

float Trk::Material::Z
inherited

Definition at line 123 of file Material.h.

◆ zOaTr

float Trk::Material::zOaTr
inherited

Definition at line 126 of file Material.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Muon::MuonStationIndex::LayerIndex
LayerIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:38
Trk::Material::Material
Material()
Default Constructor needed for POOL.
Definition: Material.h:130
Trk::Surface::materialLayer
const Trk::MaterialLayer * materialLayer() const
return the material Layer
Trk::TrackingVolume::m_confinedDetachedVolumes
std::unique_ptr< const std::vector< DetachedTrackingVolume * > > m_confinedDetachedVolumes
Additionally, Unordered subvolumes (we own the elements)
Definition: TrackingVolume.h:444
Trk::TrackingVolume::createBoundarySurfaces
void createBoundarySurfaces()
Create Boundary Surface.
Definition: TrackingVolume.cxx:828
Trk::SubtractedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: SubtractedVolumeBounds.h:122
Trk::TrackingVolume::nextLayer
const Layer * nextLayer(const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool asres=true, bool skipNavLayer=false) const
Return the next Layer if existing, NULL if no next layer corresponds.
Definition: TrackingVolume.cxx:418
Trk::Intersection
Definition: Intersection.h:24
Trk::VolumeBounds::decomposeToSurfaces
virtual std::vector< std::unique_ptr< Trk::Surface > > decomposeToSurfaces(const Amg::Transform3D &transform)=0
Method to decompose the Bounds into Surfaces, the Volume can turn them into BoundarySurfaces.
Trk::TrackingVolume::moveVolume
void moveVolume(Amg::Transform3D &shift)
move Volume
Definition: TrackingVolume.cxx:1034
Trk::BoundarySubtractedCylinderSurface
Definition: BoundarySubtractedCylinderSurface.h:38
Trk::Material::L0
float L0
Definition: Material.h:121
Trk::SimplePolygonBrepVolumeBounds
Definition: SimplePolygonBrepVolumeBounds.h:44
Trk::SubtractedCylinderSurface
Definition: SubtractedCylinderSurface.h:33
Trk::DistanceSolution
Definition: DistanceSolution.h:25
Trk::TrackingVolume::closestMaterialLayer
LayerIntersection< Amg::Vector3D > closestMaterialLayer(const Amg::Vector3D &gp, const Amg::Vector3D &dir, PropDirection pDir=alongMomentum, const BoundaryCheck &bchk=true) const
Return the closest layer with material description.
Definition: TrackingVolume.cxx:445
Trk::binZ
@ binZ
Definition: BinningType.h:49
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
Trk::Material::Z
float Z
Definition: Material.h:123
Trk::BinnedArray::nextObject
virtual T * nextObject(const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool associatedResult=true) const =0
Returns the pointer to the templated class object from the BinnedArray, takes 3D position & direction...
Trk::Volume::m_volumeBounds
std::shared_ptr< VolumeBounds > m_volumeBounds
the volumeBounds
Definition: Volume.h:80
Trk::Intersection::pathLength
double pathLength
Definition: Intersection.h:26
module_driven_slicing.layers
layers
Definition: module_driven_slicing.py:113
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
Trk::NavigationLayer
Definition: NavigationLayer.h:41
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
PlotCalibFromCool.ib
ib
Definition: PlotCalibFromCool.py:419
Trk::SubtractedPlaneLayer
Definition: SubtractedPlaneLayer.h:34
Trk::TrackingVolume::confinedDetachedVolumes
ArraySpan< DetachedTrackingVolume const *const > confinedDetachedVolumes() const
Return detached subVolumes - not the ownership.
Trk::TrackingVolume::m_boundarySurfaces
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > m_boundarySurfaces
Definition: TrackingVolume.h:438
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
Trk::TrackingVolume::m_confinedDenseVolumes
std::unique_ptr< const std::vector< TrackingVolume * > > m_confinedDenseVolumes
Additionally, Unordered Layers inside the Volume (we own the elements)
Definition: TrackingVolume.h:446
Trk::DiscSurface
Definition: DiscSurface.h:54
Trk::MaterialLayer::surfaceRepresentation
virtual const Surface & surfaceRepresentation() const override=0
Transforms the layer into a Surface representation for extrapolation.
Trk::TrackingVolume::m_confinedLayers
std::unique_ptr< LayerArray > m_confinedLayers
Array of Volumes inside the Volume.
Definition: TrackingVolume.h:440
Trk::TrackingVolume::m_confinedArbitraryLayers
std::unique_ptr< const std::vector< Layer * > > m_confinedArbitraryLayers
Definition: TrackingVolume.h:448
Trk::TrackingVolume::m_confinedVolumes
std::unique_ptr< TrackingVolumeArray > m_confinedVolumes
Detached subvolumes.
Definition: TrackingVolume.h:442
python.RingerConstants.Layer
Layer
Definition: RingerConstants.py:42
Trk::BoundaryPlaneSurface
Definition: BoundaryPlaneSurface.h:37
Trk::CombinedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: CombinedVolumeBounds.h:136
TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT
#define TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT
Definition: LayerIndex.h:19
Trk::TrackingVolume::confinedLayers
const LayerArray * confinedLayers() const
Return the subLayer array.
Trk::Layer::surfaceArray
const SurfaceArray * surfaceArray() const
Return the entire SurfaceArray, returns nullptr if no SurfaceArray.
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
Trk::PropDirection
PropDirection
Definition: PropDirection.h:19
Trk::BoundaryDiscSurface
Definition: BoundaryDiscSurface.h:39
A
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
Trk::BoundarySubtractedPlaneSurface
Definition: BoundarySubtractedPlaneSurface.h:38
Trk::Volume::Volume
Volume()=default
Defaults copies are special due ot unique ptr data member
Trk::SubtractedPlaneSurface
Definition: SubtractedPlaneSurface.h:32
Trk::LayerIndex
Definition: LayerIndex.h:37
Trk::Material::A
float A
Definition: Material.h:122
Trk::ArraySpan
std::span< T > ArraySpan
Definition: TrackingVolume.h:59
Trk::TrackingVolume::confinedArbitraryLayers
ArraySpan< Layer const *const > confinedArbitraryLayers() const
Return the confined subLayer array.
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
Trk::CylinderSurface
Definition: CylinderSurface.h:55
Trk::TrackingVolume::confinedDenseVolumes
ArraySpan< TrackingVolume const *const > confinedDenseVolumes() const
Return unordered subVolumes - not the ownership.
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Trk::TrackingVolume::m_name
std::string m_name
Volume name for debug reasons.
Definition: TrackingVolume.h:457
Trk::TrackingVolume::m_geometrySignature
GeometrySignature m_geometrySignature
Definition: TrackingVolume.h:456
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::PlaneLayer
Definition: PlaneLayer.h:40
Trk::TrackingVolume::m_colorCode
unsigned int m_colorCode
Color code for displaying.
Definition: TrackingVolume.h:458
Trk::Layer::nextLayer
const Layer * nextLayer(const Amg::Vector3D &gp, const Amg::Vector3D &udir) const
getting the next/previous Layer if registered - unit for direction vector required
Definition: Layer.cxx:161
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:90
Trk::TrackingVolume::boundarySurfaces
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > & boundarySurfaces()
Method to return the BoundarySurfaces.
Definition: TrackingVolume.cxx:809
Trk::LayerIndex::value
int value() const
layerIndex expressed in an integer
Definition: LayerIndex.h:71
Trk::Unsigned
@ Unsigned
Definition: GeometrySignature.h:33
Trk::BinnedArray::arrayObjects
virtual std::span< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
Trk::Volume::boundarySurfaceAccessor
ObjectAccessor boundarySurfaceAccessor(const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool forceInside=false) const
Provide accessor for BoundarySurfaces.
Definition: Volume.cxx:82
Trk::BinUtility::binningValue
BinningValue binningValue(size_t ba=0) const
The type/value of the binning.
Definition: BinUtility.h:230
Trk::Material::X0
float X0
Definition: Material.h:120
beamspotman.dir
string dir
Definition: beamspotman.py:619
Trk::BinUtility
Definition: BinUtility.h:39
Trk::CylinderLayer
Definition: CylinderLayer.h:43
Trk::ConstSharedPtrSpan
Definition: TrackingVolume.h:65
Trk::Layer::registerLayerIndex
void registerLayerIndex(const LayerIndex &lIdx)
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
Trk::DistanceSolution::absClosest
double absClosest() const
Absolute Distance to closest solution.
Trk::TrackingVolume::moveTV
void moveTV(Amg::Transform3D &transform)
move the Tracking Volume
Definition: TrackingVolume.cxx:1063
Trk::Volume::transform
const Amg::Transform3D & transform() const
Return methods for geometry transform.
Definition: Volume.h:83
Trk::TrackingVolume::m_geometryType
GeometryType m_geometryType
The Signature done by the GeometryBuilder.
Definition: TrackingVolume.h:454
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::TrackingVolume::m_motherVolume
const TrackingVolume * m_motherVolume
boundary Surfaces, they can be shared between volumes
Definition: TrackingVolume.h:436
Trk::Intersection::valid
bool valid
Definition: Intersection.h:28
Trk::Material::rho
float rho
Definition: Material.h:124
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
Trk::BoundaryCylinderSurface
Definition: BoundaryCylinderSurface.h:37
Trk::ObjectAccessor
Definition: ObjectAccessor.h:15
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
Trk::binR
@ binR
Definition: BinningType.h:50
Trk::TrackingVolume::createLayerAttemptsCalculator
void createLayerAttemptsCalculator()
Create Layer Attempts Caluclator.
Definition: TrackingVolume.cxx:950
CXXUTILS_TRAPPING_FP
CXXUTILS_TRAPPING_FP
Definition: SegmentLineFitter.cxx:8
mapkey::sf
@ sf
Definition: TElectronEfficiencyCorrectionTool.cxx:38
Trk::NavBinnedArray1D
Definition: NavBinnedArray1D.h:36
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Trk::TrackingVolume::nextVolume
const TrackingVolume * nextVolume(const Amg::Vector3D &gp, const Amg::Vector3D &dir, PropDirection pDir=alongMomentum) const
Return the next volume along the navigation stream.
Definition: TrackingVolume.cxx:583
Trk::TrackingVolume::confinedVolumes
const TrackingVolumeArray * confinedVolumes() const
Return the subLayer array.
Trk::Layer::previousLayer
const Layer * previousLayer(bool skipNavLayer=false) const
getting what's stored to be the previous Layer, boolean to skip navigation layers
Definition: Layer.cxx:141
DeMoScan.first
bool first
Definition: DeMoScan.py:534
Trk::SubtractedVolumeBounds
Definition: SubtractedVolumeBounds.h:40
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:96
Trk::SurfaceType::Cylinder
@ Cylinder
Trk::Layer::layerMaterialProperties
const LayerMaterialProperties * layerMaterialProperties() const
getting the LayerMaterialProperties including full/pre/post update
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
Trk::TrackingVolume::m_layerAttemptsCalculator
std::unique_ptr< LayerAttemptsCalculator > m_layerAttemptsCalculator
defines how the Extrapolator propagates through this
Definition: TrackingVolume.h:452
Trk::MaterialLayer
Definition: MaterialLayer.h:42
Trk::Material::dEdX
float dEdX
Definition: Material.h:125
Trk::Material::zOaTr
float zOaTr
Definition: Material.h:126
Trk::Volume::m_transform
std::unique_ptr< Amg::Transform3D > m_transform
Transform3D (optional)
Definition: Volume.h:78
Trk::FullIntersection
Class extension to return the object, a represenation & the result.
Definition: Intersection.h:64
Trk::TrackingVolume::interlinkLayers
void interlinkLayers()
Register Next - Previous for Layers, set volumelink.
Definition: TrackingVolume.cxx:967
Trk::BinnedArray
Definition: BinnedArray.h:36
Trk::CombinedVolumeBounds
Definition: CombinedVolumeBounds.h:44
Trk::TrackingVolume::m_outsideGlueVolumes
CxxUtils::CachedUniquePtrT< GlueVolumesDescriptor > m_outsideGlueVolumes
provided the number of layer attempts
Definition: TrackingVolume.h:450
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
Trk::Volume
Definition: Volume.h:36
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Trk::TrackingVolume
Definition: TrackingVolume.h:119
Trk::TrackingVolume::associatedLayer
const Layer * associatedLayer(const Amg::Vector3D &gp) const
Return the associated Layer.
Definition: TrackingVolume.cxx:382
Trk::mappingMode
@ mappingMode
Definition: PropDirection.h:23
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
Trk::SubtractedCylinderLayer
Definition: SubtractedCylinderLayer.h:36
Trk::Layer
Definition: Layer.h:72
Trk::Layer::layerIndex
const LayerIndex & layerIndex() const
get the layerIndex
Trk::Volume::m_center
Amg::Vector3D m_center
center position of the surface
Definition: Volume.h:79
Generated on Fri Oct 24 2025 22:12:26 for ATLAS Offline Software by   doxygen 1.8.18