Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
Trk::AlignableTrackingVolume Class Reference

#include <AlignableTrackingVolume.h>

Inheritance diagram for Trk::AlignableTrackingVolume:
Collaboration diagram for Trk::AlignableTrackingVolume:

Public Member Functions

 AlignableTrackingVolume ()=default
 Default Constructor. More...
 
virtual ~AlignableTrackingVolume () override=default
 
 AlignableTrackingVolume (Amg::Transform3D *htrans, Amg::Transform3D *align, VolumeBounds *volbounds, const BinnedMaterial *matprop, int sampleID, const std::string &volumeName="undefined")
 Constructor. More...
 
const TrackingVolume * alignedTrackingVolume () const
 returns the alignedTrackingVolume More...
 
int identify () const
 returns the id More...
 
const BinnedMaterial * binnedMaterial () const
 access to binned material More...
 
virtual bool isAlignable () const override final
 
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...
 
void forceNavigationCheck ()
 force a navigation check More...
 
bool redoNavigation () const
 Boolean, if true navigation needs to be redone when hitting this volume. 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...
 
void clear ()
 remove content More...
 
void screenDump (MsgStream &msg) const
 
virtual Volume * clone () const
 Pseudo-constructor. 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 Member Functions

TrackingVolume * cloneTV (Amg::Transform3D &transform) const
 clone at new position More...
 

Protected Attributes

std::unique_ptr< Amg::Transform3D > m_transform
 HepGeom::Transform3D. More...
 
CxxUtils::CachedUniquePtr< Amg::Vector3D > m_center
 center position of the surface More...
 
std::shared_ptr< VolumeBounds > m_volumeBounds
 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...
 

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

std::unique_ptr< Amg::Transform3D > m_alignment = nullptr
 
std::unique_ptr< TrackingVolume > m_alignedTV = nullptr
 
std::unique_ptr< const BinnedMaterial > m_binnedMaterial = nullptr
 
int m_sampleID {}
 
const TrackingVolume * m_motherVolume
 mother volume of this volume More...
 
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > m_boundarySurfaces {}
 
LayerArray * m_confinedLayers
 Array of Volumes inside the Volume. More...
 
TrackingVolumeArray * m_confinedVolumes
 Detached subvolumes. More...
 
const std::vector< DetachedTrackingVolume * > * m_confinedDetachedVolumes
 Additionally, Unordered subvolumes (we ownd them) More...
 
const std::vector< TrackingVolume * > * m_confinedDenseVolumes
 
const std::vector< Layer * > * m_confinedArbitraryLayers
 < Additionally, Unordered Layers inside the Volume (we own them) More...
 
CxxUtils::CachedUniquePtrT< GlueVolumesDescriptor > m_outsideGlueVolumes
 provided the number of layer attempts More...
 
LayerAttemptsCalculator * m_layerAttemptsCalculator
 The Signature done by the GeometryBuilder. More...
 
GeometrySignature m_geometrySignature
 defines how the Extrapolator propagates through this More...
 
GeometryType m_geometryType
 
std::string m_name
 Volume name for debug reasons. More...
 
unsigned int m_colorCode
 Color code for displaying. More...
 
bool m_redoNavigation
 Navigation boolean. More...
 

Detailed Description

Base Class for a navigation object (active) in the Calo realm. Takes BinnedMaterial as an argument ( can be dummy )

Author
Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 36 of file AlignableTrackingVolume.h.

Constructor & Destructor Documentation

◆ AlignableTrackingVolume() [1/2]

Trk::AlignableTrackingVolume::AlignableTrackingVolume ( )
default

Default Constructor.

◆ ~AlignableTrackingVolume()

virtual Trk::AlignableTrackingVolume::~AlignableTrackingVolume ( )
overridevirtualdefault

◆ AlignableTrackingVolume() [2/2]

Trk::AlignableTrackingVolume::AlignableTrackingVolume ( Amg::Transform3D *  htrans,
Amg::Transform3D *  align,
VolumeBounds *  volbounds,
const BinnedMaterial *  matprop,
int  sampleID,
const std::string &  volumeName = "undefined" 
)

Constructor.

Definition at line 15 of file AlignableTrackingVolume.cxx.

22  : Trk::TrackingVolume(htrans, volbounds, *matprop, nullptr, nullptr, volumeName),
23  m_alignment(align),
24  m_alignedTV(nullptr),
25  m_binnedMaterial(matprop),
26  m_sampleID(sampleID){
27  if (m_alignment) {
28  m_alignedTV = std::unique_ptr<TrackingVolume>(this->cloneTV(*m_alignment));
29  }
30 }

Member Function Documentation

◆ addMaterial()

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

add Material

Definition at line 906 of file TrackingVolume.cxx.

907 {
908  // assume the scaling factor refers to the volume scaling
909  float flin = pow(fact, 0.33);
910  // average X0
911  double invX0 = X0 > 0. ? 1. / X0 : 0.;
912  double sum_invX0 = invX0 + flin / mprop.X0;
913  X0 = 1. / sum_invX0;
914  // average L0
915  double invL0 = L0 > 0. ? 1. / L0 : 0.;
916  double sum_invL0 = invL0 + flin / mprop.L0;
917  L0 = 1. / sum_invL0;
918  // add density
919  float rho1 = rho;
920  rho += fact * mprop.rho;
921  // averageZ
922  float n1 = Z > 0. ? rho1 / Z : 0.;
923  float n2 = fact * mprop.rho / mprop.Z;
924  Z = rho / (n1 + n2);
925  // averageA
926  n1 = A > 0. ? rho1 / A : 0.;
927  n2 = fact * mprop.rho / mprop.A;
928  A = rho / (n1 + n2);
929  // zOverAtimesRho
930  zOaTr = Z / A * rho;
931  // mean energy loss (linear scaling)
932  dEdX += flin * mprop.dEdX;
933 }

◆ alignedTrackingVolume()

const Trk::TrackingVolume * Trk::AlignableTrackingVolume::alignedTrackingVolume ( ) const

returns the alignedTrackingVolume

Definition at line 32 of file AlignableTrackingVolume.cxx.

32  {
33  if (m_alignedTV) {
34  return m_alignedTV.get();
35  }
36  return this;
37 }

◆ assocDetachedSubVolumes()

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

Return the associated detached subvolumes.

Definition at line 795 of file TrackingVolume.cxx.

797 {
798  auto currVols = std::vector<const Trk::DetachedTrackingVolume*>();
799 
800  Trk::ArraySpan<const Trk::DetachedTrackingVolume* const> detVols =
801  confinedDetachedVolumes();
802  if (!detVols.empty()) {
803  for (const auto *detVol : detVols) {
804  if (detVol->trackingVolume()->inside(gp, tol))
805  currVols.push_back(detVol);
806  }
807  }
808  return currVols;
809 }

◆ associatedLayer() [1/2]

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

Definition at line 581 of file TrackingVolume.cxx.

582 {
583  // confined layers
584  if (m_confinedLayers)
585  return (confinedLayers()->object(gp));
586  // confined arbitrary
587  if (m_confinedArbitraryLayers) {
588  for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
589  if (confinedArbitraryLayer->isOnLayer(gp)){
590  return confinedArbitraryLayer;
591  }
592  }
593  }
594  return nullptr;
595 }

◆ associatedLayer() [2/2]

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

Return the associated Layer.

Definition at line 564 of file TrackingVolume.cxx.

565 {
566  // confined layers
567  if (m_confinedLayers)
568  return (confinedLayers()->object(gp));
569  // confined arbitrary
570  if (m_confinedArbitraryLayers) {
571  for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
572  if (confinedArbitraryLayer->isOnLayer(gp)){
573  return confinedArbitraryLayer;
574  }
575  }
576  }
577  return nullptr;
578 }

◆ associatedSubVolume() [1/2]

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

Definition at line 729 of file TrackingVolume.cxx.

730 {
731  if (m_confinedVolumes)
732  return (m_confinedVolumes->object(gp));
733 
734  if (m_confinedDetachedVolumes) {
735  for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
736  if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
737  return confinedDetachedVolume->trackingVolume();
738  }
739  }
740  }
741 
742  if (m_confinedDenseVolumes) {
743  for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
744  if (confinedDenseVolume->inside(gp, 0.001)){
745  return confinedDenseVolume;
746  }
747  }
748  }
749 
750  return this;
751 }

◆ associatedSubVolume() [2/2]

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

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

Definition at line 705 of file TrackingVolume.cxx.

706 {
707  if (m_confinedVolumes)
708  return (m_confinedVolumes->object(gp));
709 
710  if (m_confinedDetachedVolumes) {
711  for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
712  if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
713  return confinedDetachedVolume->trackingVolume();
714  }
715  }
716  }
717 
718  if (m_confinedDenseVolumes) {
719  for (auto *confinedDenseVolume : *m_confinedDenseVolumes)
720  if (confinedDenseVolume->inside(gp, 0.001)){
721  return confinedDenseVolume;
722  }
723  }
724 
725  return this;
726 }

◆ averageZ()

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

Definition at line 228 of file Material.h.

228 { return (*this).Z; }

◆ binnedMaterial()

const BinnedMaterial * Trk::AlignableTrackingVolume::binnedMaterial ( ) const
inline

access to binned material

Definition at line 70 of file AlignableTrackingVolume.h.

70  {
71  return m_binnedMaterial.get();
72 }

◆ boundarySurface()

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

Get the BoundarySurface to the appointed Accessor state.

Definition at line 990 of file TrackingVolume.cxx.

991 {
992  return (std::as_const(m_boundarySurfaces)[oa]).get();
993 }

◆ 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 100 of file Volume.cxx.

104 {
105  if (!m_transform) {
106  return Trk::ObjectAccessor(
107  volumeBounds().boundarySurfaceAccessor(gp, dir, forceInside));
108  }
109  return Trk::ObjectAccessor(volumeBounds().boundarySurfaceAccessor(
110  transform().inverse() * gp, dir, forceInside));
111 }

◆ boundarySurfaces() [1/2]

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

Method to return the BoundarySurfaces.

Definition at line 977 of file TrackingVolume.cxx.

978 {
979  return m_boundarySurfaces;
980 }

◆ boundarySurfaces() [2/2]

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

Definition at line 983 of file TrackingVolume.cxx.

984 {
985  return Trk::ConstSharedPtrSpan<Trk::BoundarySurface<Trk::TrackingVolume>>(
986  m_boundarySurfaces);
987 }

◆ boundarySurfacesOrdered()

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

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 86 of file Volume.h.

87  {
88  if (m_center) return (*m_center);
89  if (!m_center && m_transform){
90  m_center.set(std::make_unique<Amg::Vector3D>(std::as_const(*m_transform).translation()));
91  return(*m_center);
92  }
93  return Trk::s_origin;
94  }

◆ checkoutConfinedLayers()

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

Return the subLayerarray including the ownership.

Definition at line 1179 of file TrackingVolume.cxx.

1180 {
1181  const Trk::LayerArray* checkoutLayers = m_confinedLayers;
1182  return checkoutLayers;
1183 }

◆ clear()

void Trk::TrackingVolume::clear ( )
inherited

remove content

Definition at line 537 of file TrackingVolume.cxx.

538 {
539  if (m_confinedVolumes) {
540  delete m_confinedVolumes;
541  m_confinedVolumes = nullptr;
542  }
543  if (m_confinedLayers) {
544  delete m_confinedLayers;
545  m_confinedLayers = nullptr;
546  }
547  if (m_confinedDenseVolumes) {
548  for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
549  delete confinedDenseVolume;
550  }
551  delete m_confinedDenseVolumes;
552  m_confinedDenseVolumes = nullptr;
553  }
554  if (m_confinedArbitraryLayers) {
555  for (auto *confinedArbitraryLayer : *m_confinedArbitraryLayers){
556  delete confinedArbitraryLayer;
557  }
558  delete m_confinedArbitraryLayers;
559  m_confinedArbitraryLayers = nullptr;
560  }
561 }

◆ clone()

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

Pseudo-constructor.

Reimplemented in Trk::AbstractVolume.

Definition at line 78 of file Volume.cxx.

79 {
80  return new Trk::Volume(*this);
81 }

◆ cloneTV()

Trk::TrackingVolume * Trk::TrackingVolume::cloneTV ( Amg::Transform3D &  transform) const
protectedinherited

clone at new position

Definition at line 1222 of file TrackingVolume.cxx.

1223 {
1224  // clone the mother volume
1225  Trk::Volume* vol = Trk::Volume::clone();
1226 
1227  // clone 'ordered layers
1228  Trk::LayerArray* layerArray = nullptr;
1229  // confined layers
1230  const Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1231  if (confLayers) {
1232  // retrieve array objects and apply the transform
1233  Trk::BinnedArraySpan<Trk::Layer const * const> layers = confLayers->arrayObjects();
1234  std::vector<std::shared_ptr<Trk::Layer>> layerOrder;
1235  for (const auto *layer : layers) {
1236  const Trk::PlaneLayer* lay =
1237  dynamic_cast<const Trk::PlaneLayer*>(layer);
1238  if (lay) {
1239  Trk::PlaneLayer* newlay = new Trk::PlaneLayer(*lay, transform);
1240  layerOrder.push_back(std::shared_ptr<Trk::Layer>(newlay));
1241  }
1242  }
1243  // recreate LayerArray
1244  const Trk::NavBinnedArray1D<Trk::Layer>* confLaysNav =
1245  dynamic_cast<const Trk::NavBinnedArray1D<Trk::Layer>*>(confLayers);
1246  if (confLaysNav)
1247  layerArray = new Trk::NavBinnedArray1D<Trk::Layer>(
1248  *confLaysNav,
1249  std::vector<std::shared_ptr<Trk::Layer>>(layerOrder),
1250  transform);
1251  }
1252 
1253  // clone 'unordered' layers
1254  std::vector<Trk::Layer*>* unorderedLayers = nullptr;
1255  Trk::ArraySpan<const Trk::Layer* const> confArbLayers =
1256  confinedArbitraryLayers();
1257  if (!confArbLayers.empty()) {
1258  // clone & apply the transform
1259  std::vector<Trk::Layer*> uLayers;
1260  for (const auto *confArbLayer : confArbLayers) {
1261  const Trk::SubtractedPlaneLayer* slayer =
1262  dynamic_cast<const Trk::SubtractedPlaneLayer*>(confArbLayer);
1263  const Trk::SubtractedCylinderLayer* sclayer =
1264  dynamic_cast<const Trk::SubtractedCylinderLayer*>(confArbLayer);
1265  const Trk::PlaneLayer* layer =
1266  dynamic_cast<const Trk::PlaneLayer*>(confArbLayer);
1267  const Trk::CylinderLayer* clayer =
1268  dynamic_cast<const Trk::CylinderLayer*>(confArbLayer);
1269 
1270  if (slayer) {
1271  Trk::SubtractedPlaneLayer* lay = new Trk::SubtractedPlaneLayer(*slayer);
1272  lay->moveLayer(transform);
1273  uLayers.push_back(lay);
1274  } else if (layer) {
1275  Trk::PlaneLayer* lay = new Trk::PlaneLayer(*layer);
1276  lay->moveLayer(transform);
1277  uLayers.push_back(lay);
1278  } else if (sclayer) {
1279  Trk::SubtractedCylinderLayer* lay =
1280  new Trk::SubtractedCylinderLayer(*sclayer);
1281  lay->moveLayer(transform);
1282  uLayers.push_back(lay);
1283  } else if (clayer) {
1284  Trk::CylinderLayer* lay = new Trk::CylinderLayer(*clayer);
1285  lay->moveLayer(transform);
1286  uLayers.push_back(lay);
1287  }
1288  }
1289  unorderedLayers = new std::vector<Trk::Layer*>(uLayers);
1290  }
1291 
1292  // cloning confined volumes
1293  Trk::TrackingVolumeArray* volumeArray = nullptr;
1294  const Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1295  if (confVolumes) {
1296  // retrieve array objects and apply the transform
1297  Trk::BinnedArraySpan<Trk::TrackingVolume const* const> volumes = confVolumes->arrayObjects();
1298  std::vector<std::shared_ptr<TrackingVolume>> volOrder;
1299  for (const auto *volume : volumes) {
1300  Trk::TrackingVolume* vol = volume->cloneTV(transform);
1301  volOrder.push_back(std::shared_ptr<TrackingVolume>(vol));
1302  }
1303  // recreate TrackingVolumeArray
1304  const Trk::NavBinnedArray1D<Trk::TrackingVolume>* confVolsNav =
1305  dynamic_cast<const Trk::NavBinnedArray1D<Trk::TrackingVolume>*>(
1306  confVolumes);
1307  if (confVolsNav)
1308  volumeArray = new Trk::NavBinnedArray1D<Trk::TrackingVolume>(
1309  *confVolsNav, std::vector<std::shared_ptr<TrackingVolume>>(volOrder), transform);
1310  }
1311 
1312  // cloning confined unordered volumes
1313  Trk::ArraySpan<const Trk::TrackingVolume* const> confDenseVolumes =
1314  confinedDenseVolumes();
1315  std::vector<Trk::TrackingVolume*>* newDenseVol = nullptr;
1316  if (!confDenseVolumes.empty()) {
1317  std::vector<Trk::TrackingVolume*> newVol;
1318  // retrieve array objects and apply the transform
1319  for (const auto *confDenseVolume : confDenseVolumes) {
1320  Trk::TrackingVolume* vol =
1321  confDenseVolume->cloneTV(transform);
1322  newVol.push_back(vol);
1323  }
1324  newDenseVol = new std::vector<Trk::TrackingVolume*>(newVol);
1325  }
1326 
1327  // create the Tracking Volume
1328  Trk::TrackingVolume* newTrkVol = nullptr;
1329  if (!confArbLayers.empty() || !confDenseVolumes.empty()) {
1330  if (!confArbLayers.empty() && !confDenseVolumes.empty()) {
1331  newTrkVol = new Trk::TrackingVolume(
1332  *vol, unorderedLayers, newDenseVol, *this, volumeName());
1333  } else if (!confArbLayers.empty()) {
1334  newTrkVol =
1335  new Trk::TrackingVolume(*vol, *this, unorderedLayers, volumeName());
1336  } else {
1337  newTrkVol =
1338  new Trk::TrackingVolume(*vol, *this, newDenseVol, volumeName());
1339  }
1340  delete layerArray;
1341  } else {
1342  newTrkVol = new Trk::TrackingVolume(
1343  *vol, *this, layerArray, volumeArray, volumeName());
1344  }
1345  delete vol;
1346  // finally, position the mother volume
1347  newTrkVol->moveVolume(transform);
1348  // create boundary surfaces
1349  newTrkVol->m_boundarySurfaces.clear();
1350  newTrkVol->createBoundarySurfaces();
1351 
1352  delete volumeArray;
1353  return newTrkVol;
1354 }

◆ closest()

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

Helper method - find closest of two layers.

Definition at line 1357 of file TrackingVolume.cxx.

1361 {
1362  // use the distance solution for assigning the layer
1363  Trk::DistanceSolution distSolToPrevious =
1364  first.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
1365  Trk::DistanceSolution distSolToNext =
1366  second.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
1367  // find out which one
1368  return (distSolToPrevious.absClosest() < distSolToNext.absClosest()
1369  ? &first
1370  : &second);
1371 }

◆ closestMaterialLayer()

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

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 623 of file TrackingVolume.cxx.

627 {
628  // the layer candidates to check
629  std::vector<const Layer*> layerCandidates;
630 
631  // ---------------- BOUNDARY LAYER SECTION (only for mapping) ----------
632  if (pDir == mappingMode) {
633  const auto& bSurfaces = boundarySurfaces();
634  for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
635  if (bSurfaces[ib]->surfaceRepresentation().materialLayer())
636  layerCandidates.push_back(
637  bSurfaces[ib]->surfaceRepresentation().materialLayer());
638  }
639  }
640  // ---------------- CONFINED LAYER SECTION --------------
641  if (m_confinedLayers) {
642  // the associated layer
643  const Trk::Layer* assocLayer = associatedLayer(gp);
644  const Trk::Layer* previousMatLayer = nullptr;
645  const Trk::Layer* nextMatLayer = nullptr;
646  // if the associated layer is a navigation layer - get the previous and next
647  // from this one
648  const Trk::NavigationLayer* navLayer =
649  dynamic_cast<const Trk::NavigationLayer*>(assocLayer);
650  if (navLayer) {
651  // get previous / next
652  previousMatLayer = navLayer->previousLayer();
653  nextMatLayer = navLayer->nextLayer();
654  if (previousMatLayer)
655  layerCandidates.push_back(previousMatLayer);
656  if (nextMatLayer)
657  layerCandidates.push_back(nextMatLayer);
658  } else
659  layerCandidates.push_back(assocLayer);
660  }
661  // --- solve for the layer candidates ---------------------
662  //
663  Trk::Intersection laySurfIntersection(
664  Amg::Vector3D(0., 0., 0.), 10e10, false);
665  // layer candidates found - continue
666  if (!layerCandidates.empty()) {
667  const Layer* cLayer = nullptr;
668  // iterate through and chose
669  for (auto& lcIter : layerCandidates) {
670  // only the forceFwd solution is possible here
671  bool forceDir = (pDir == alongMomentum || pDir == oppositeMomentum);
672  double dirScalor = (pDir == oppositeMomentum) ? -1. : 1.;
673  // get the intersection soltuion
674  Trk::Intersection sfI =
675  (*lcIter).surfaceRepresentation().straightLineIntersection(
676  gp, dirScalor * dir, forceDir, bchk);
677  if (sfI.valid &&
678  (sfI.pathLength * sfI.pathLength) <
679  (laySurfIntersection.pathLength * laySurfIntersection.pathLength)) {
680  laySurfIntersection = sfI;
681  cLayer = lcIter;
682  }
683  }
684  // now return the pair: in case of a valid intersection, or if no mapping
685  // mode is chosen
686  if (cLayer)
687  return Trk::LayerIntersection<Amg::Vector3D>(
688  laySurfIntersection,
689  cLayer,
690  &(cLayer->surfaceRepresentation()),
691  nullptr,
692  pDir);
693  }
694  // mapping mode chosen, but no valid intersection yet
695  const Trk::TrackingVolume* nVolume = nextVolume(gp, dir, pDir);
696 
697  // forward the next Volume solution or a 0 solution
698  return (nVolume && nVolume != this)
699  ? nVolume->closestMaterialLayer(gp, dir, pDir, bchk)
700  : Trk::LayerIntersection<Amg::Vector3D>(
701  laySurfIntersection, nullptr, nullptr, nullptr, pDir);
702 }

◆ colorCode()

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

Get the color code.

◆ compactify()

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

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 1442 of file TrackingVolume.cxx.

1443 {
1444  // confined 'ordered' layers
1445  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1446  if (confLayers) {
1447  Trk::BinnedArraySpan<Trk::Layer* const> layers = confLayers->arrayObjects();
1448  for (const auto& clayIter : layers) {
1449  if (&(*clayIter) != nullptr)
1450  clayIter->compactify(cSurfaces, tSurfaces);
1451  else
1452  std::cout << "WARNING: Attempt to compactify nullptr layer in volume : "
1453  << volumeName() << std::endl;
1454  }
1455  }
1456  // confined 'unordered' layers
1457  Trk::ArraySpan<Trk::Layer* const> confArbLayers = confinedArbitraryLayers();
1458  if (!confArbLayers.empty()) {
1459  for (const auto& calayIter : confArbLayers) {
1460  if (calayIter != nullptr) {
1461  calayIter->compactify(cSurfaces, tSurfaces);
1462  } else {
1463  std::cout << "WARNING: Attempt to compactify nullptr layer."
1464  << std::endl;
1465  }
1466  }
1467  }
1468  // confined volumes
1469  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1470  if (confVolumes) {
1471  Trk::BinnedArraySpan<Trk::TrackingVolume* const> volumes =
1472  confVolumes->arrayObjects();
1473  for (const auto& cVolumesIter : volumes) {
1474  cVolumesIter->compactify(cSurfaces, tSurfaces);
1475  }
1476  }
1477  // confined unordered volumes
1478  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes =
1479  confinedDenseVolumes();
1480  if (!confDenseVolumes.empty())
1481  for (const auto& cVolumesIter : (confDenseVolumes)) {
1482  cVolumesIter->compactify(cSurfaces, tSurfaces);
1483  }
1484 
1485  // detached volumes if any
1486  if (m_confinedDetachedVolumes)
1487  for (const auto& cdVolumesIter : (*m_confinedDetachedVolumes)) {
1488  cdVolumesIter->compactify(cSurfaces, tSurfaces);
1489  }
1490 }

◆ confinedArbitraryLayers() [1/2]

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

Return the confined subLayer array.

Layers are not const

◆ confinedArbitraryLayers() [2/2]

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

Return the confined subLayer array.

◆ confinedDenseVolumes() [1/2]

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

◆ confinedDenseVolumes() [2/2]

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

Return unordered subVolumes - not the ownership.

◆ confinedDetachedVolumes() [1/2]

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

◆ confinedDetachedVolumes() [2/2]

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

Return detached subVolumes - not the ownership.

◆ confinedLayers() [1/2]

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

Return the subLayer array.

◆ confinedLayers() [2/2]

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

Return the subLayer array.

◆ confinedVolumes() [1/2]

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

Return the subLayer array.

◆ confinedVolumes() [2/2]

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

Return the subLayer array.

◆ createBoundarySurfaces()

void Trk::TrackingVolume::createBoundarySurfaces ( )
privateinherited

Create Boundary Surface.

Definition at line 996 of file TrackingVolume.cxx.

997 {
998  // prepare the BoundarySurfaces
999  m_boundarySurfaces =
1000  std::vector<std::shared_ptr<Trk::BoundarySurface<Trk::TrackingVolume>>>();
1001  // transform Surfaces To BoundarySurfaces
1002  const std::vector<const Trk::Surface*>* surfaces =
1003  Trk::Volume::volumeBounds().decomposeToSurfaces(transform());
1004  std::vector<const Trk::Surface*>::const_iterator surfIter = surfaces->begin();
1005 
1006  // counter to flip the inner/outer position for Cylinders
1007  unsigned int sfCounter = 0;
1008  unsigned int sfNumber = surfaces->size();
1009 
1010  // memory optimisation
1011  m_boundarySurfaces.reserve(sfNumber + 1);
1012 
1013  // identify Subtracted/CombinedVolumes
1014  const Trk::SubtractedVolumeBounds* subtrVol =
1015  dynamic_cast<const Trk::SubtractedVolumeBounds*>(
1016  &(Trk::Volume::volumeBounds()));
1017  const Trk::CombinedVolumeBounds* combVol =
1018  dynamic_cast<const Trk::CombinedVolumeBounds*>(
1019  &(Trk::Volume::volumeBounds()));
1020  bool subtr = (subtrVol) ? 1 : 0;
1021  bool comb = (combVol) ? 1 : 0;
1022 
1023  if (!subtr && !comb) {
1024  const Trk::SimplePolygonBrepVolumeBounds* spbVol =
1025  dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
1026  &(Trk::Volume::volumeBounds()));
1027 
1028  for (; surfIter != surfaces->end(); ++surfIter) {
1029  sfCounter++;
1030 
1031  Trk::TrackingVolume* in = this;
1032  Trk::TrackingVolume* out = nullptr;
1033 
1034  // ST update: subtracted surfaces may appear in 'simple' volumes
1035  // (SimplePolygonBrep...)
1036  const Trk::SubtractedPlaneSurface* spsf =
1037  dynamic_cast<const Trk::SubtractedPlaneSurface*>(*surfIter);
1038  const Trk::PlaneSurface* psf =
1039  dynamic_cast<const Trk::PlaneSurface*>(*surfIter);
1040  if (spsf) {
1041  if (spbVol && sfCounter == 1) {
1042  in = nullptr;
1043  out = this;
1044  }
1045  m_boundarySurfaces.push_back(
1046  std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
1047  in, out, *spsf));
1048  delete spsf;
1049  continue;
1050  }
1051  if (psf) {
1052  m_boundarySurfaces.push_back(
1053  std::make_shared<Trk::BoundaryPlaneSurface<Trk::TrackingVolume>>(in, out, *psf));
1054  delete psf;
1055  continue;
1056  }
1057 
1058  const Trk::DiscSurface* dsf =
1059  dynamic_cast<const Trk::DiscSurface*>(*surfIter);
1060  if (dsf) {
1061  m_boundarySurfaces.push_back(
1062  std::make_shared<Trk::BoundaryDiscSurface<Trk::TrackingVolume>>(in, out, *dsf));
1063  delete dsf;
1064  continue;
1065  }
1066 
1067  const Trk::SubtractedCylinderSurface* scsf =
1068  dynamic_cast<const Trk::SubtractedCylinderSurface*>(*surfIter);
1069  const Trk::CylinderSurface* csf =
1070  dynamic_cast<const Trk::CylinderSurface*>(*surfIter);
1071  if (scsf) {
1072  Trk::TrackingVolume* inner =
1073  (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
1074  Trk::TrackingVolume* outer = (inner) ? nullptr : this;
1075  m_boundarySurfaces.push_back(
1076  std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(inner, outer, *scsf));
1077  delete scsf;
1078  continue;
1079  }
1080  if (csf) {
1081  Trk::TrackingVolume* inner =
1082  (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
1083  Trk::TrackingVolume* outer = (inner) ? nullptr : this;
1084  m_boundarySurfaces.push_back(
1085  std::make_shared<Trk::BoundaryCylinderSurface<Trk::TrackingVolume>>(
1086  inner, outer, *csf));
1087  delete csf;
1088  continue;
1089  }
1090  }
1091 
1092  } else {
1093  const std::vector<bool> bOrient =
1094  subtrVol ? subtrVol->boundsOrientation() : combVol->boundsOrientation();
1095 
1096  for (; surfIter != surfaces->end(); ++surfIter) {
1097  Trk::TrackingVolume* in = bOrient[sfCounter] ? this : nullptr;
1098  Trk::TrackingVolume* out = bOrient[sfCounter] ? nullptr : this;
1099  sfCounter++;
1100 
1101  const Trk::SubtractedPlaneSurface* psf =
1102  dynamic_cast<const Trk::SubtractedPlaneSurface*>(*surfIter);
1103  if (psf) {
1104  m_boundarySurfaces.push_back(
1105  std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
1106  in, out, *psf));
1107  delete psf;
1108  continue;
1109  }
1110 
1111  const Trk::SubtractedCylinderSurface* csf =
1112  dynamic_cast<const Trk::SubtractedCylinderSurface*>(*surfIter);
1113  if (csf) {
1114  m_boundarySurfaces.push_back(
1115  std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(
1116  in, out, *csf));
1117  delete csf;
1118  continue;
1119  }
1120  }
1121  }
1122 
1123  delete surfaces;
1124 }

◆ createLayerAttemptsCalculator()

void Trk::TrackingVolume::createLayerAttemptsCalculator ( )
privateinherited

Create Layer Attempts Caluclator.

Definition at line 1127 of file TrackingVolume.cxx.

1128 {
1129  // check whether there's a static array
1130  if (m_confinedLayers) {
1131  // BinUtility
1132  const Trk::BinUtility* binUtility = m_confinedLayers->binUtility();
1133  if (binUtility) {
1134  if (binUtility->binningValue() == Trk::binR)
1135  m_layerAttemptsCalculator =
1136  new Trk::CylinderLayerAttemptsCalculator(1, 5);
1137  if (binUtility->binningValue() == Trk::binZ)
1138  m_layerAttemptsCalculator = new Trk::DiscLayerAttemptsCalculator(1, 5);
1139  }
1140  }
1141 }

◆ entryLayer()

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

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
inherited

Return the exit Layer from a TrackingVolume.

◆ forceNavigationCheck()

void Trk::TrackingVolume::forceNavigationCheck ( )
inherited

force a navigation check

◆ geometrySignature()

GeometrySignature Trk::TrackingVolume::geometrySignature ( ) const
inherited

return the Signature

◆ geometryType()

GeometryType Trk::TrackingVolume::geometryType ( ) const
inherited

return the Signature

◆ getMotherVolume()

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

Return the MotherVolume - if it exists.

◆ glueVolumesDescriptor() [1/2]

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

Definition at line 1192 of file TrackingVolume.cxx.

1193 {
1194  if (!m_outsideGlueVolumes) {
1195  m_outsideGlueVolumes.store(std::make_unique<Trk::GlueVolumesDescriptor>());
1196  }
1197  return (*m_outsideGlueVolumes);
1198 }

◆ glueVolumesDescriptor() [2/2]

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

Definition at line 1201 of file TrackingVolume.cxx.

1202 {
1203  if (!m_outsideGlueVolumes) {
1204  m_outsideGlueVolumes.set(std::make_unique<Trk::GlueVolumesDescriptor>());
1205  }
1206  return (*m_outsideGlueVolumes);
1207 }

◆ identify()

int Trk::AlignableTrackingVolume::identify ( ) const
inline

returns the id

Definition at line 66 of file AlignableTrackingVolume.h.

66  {
67  return m_sampleID;
68 }

◆ indexContainedMaterialLayers()

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

reIndex the material layers of the TrackingVolume

Definition at line 859 of file TrackingVolume.cxx.

861 {
862  // the offset gets increased internally
863  // the static layers first and check if they have surfaces with material
864  // layers that need index
865  if (m_confinedLayers) {
866  Trk::BinnedArraySpan<Trk::Layer * const> layers = confinedLayers()->arrayObjects();
867  for (Trk::Layer* layerIter : layers) {
868  // only index the material layers & only those that have not yet been
869  // singed
870  if (layerIter) {
871  Trk::SurfaceArray* surfArray = layerIter->surfaceArray();
872  if (surfArray) {
873  Trk::BinnedArraySpan<Trk::Surface * const> layerSurfaces = surfArray->arrayObjects();
874  // loop over the surfaces - there can be 0 entries
875  for (Trk::Surface* const laySurf : layerSurfaces) {
876  Trk::Layer* materialLayer = laySurf ? laySurf->materialLayer() : nullptr;
877  if (materialLayer && materialLayer->layerIndex().value() < 0) {
878  // sign only those with material properties - rest goes to 0
879  Trk::LayerIndex layIndex =
880  materialLayer->layerMaterialProperties()
881  ? Trk::LayerIndex(int(geoSig) *
882  TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT +
883  (++offset))
884  : Trk::LayerIndex(0);
885  // now register the index
886  materialLayer->registerLayerIndex(layIndex);
887  }
888  }
889  }
890  }
891  }
892  }
893 
894  // step down the hierarchy to the contained volumes and index those
895  // ------------------------
896  if (confinedVolumes()) {
897  Trk::BinnedArraySpan<Trk::TrackingVolume * const> volumes = confinedVolumes()->arrayObjects();
898  for (Trk::TrackingVolume* volumesIter : volumes) {
899  if (volumesIter)
900  volumesIter->indexContainedMaterialLayers(geoSig, offset);
901  }
902  }
903 }

◆ indexContainedStaticLayers()

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

reIndex the static layers of the TrackingVolume

Definition at line 812 of file TrackingVolume.cxx.

814 {
815  // the offset gets increased internally
816  // the static layers first
817  // ------------------------------------------------------------------
818  if (m_confinedLayers) {
819  Trk::BinnedArraySpan<Trk::Layer* const> layers = confinedLayers()->arrayObjects();
820  for (Trk::Layer* layerptr : layers) {
821  // only index the material layers & only those that have not yet been
822  // singed
823  if (layerptr && layerptr->layerIndex().value() < 0) {
824  // sign only those with material properties - rest goes to 0
825  Trk::LayerIndex layIndex =
826  layerptr->layerMaterialProperties()
827  ? Trk::LayerIndex(
828  int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset))
829  : Trk::LayerIndex(0);
830  // now register the index
831  layerptr->registerLayerIndex(layIndex);
832  }
833  }
834  }
835 
836  // the boundary surface layer
837  auto& bSurfaces = boundarySurfaces();
838  for (const auto& bsIter : bSurfaces) {
839  Trk::Layer* mLayer = bsIter->surfaceRepresentation().materialLayer();
840  if (mLayer && mLayer->layerIndex().value() < 0.) {
841  Trk::LayerIndex layIndex = Trk::LayerIndex(
842  int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset));
843  mLayer->registerLayerIndex(layIndex);
844  }
845  }
846 
847  // step down the hierarchy to the contained volumes and index those
848  // ------------------------
849  if (confinedVolumes()) {
850  Trk::BinnedArraySpan<Trk::TrackingVolume* const > volumes = confinedVolumes()->arrayObjects();
851  for (const auto& volumesIter : volumes) {
852  if (volumesIter)
853  volumesIter->indexContainedStaticLayers(geoSig, offset);
854  }
855  }
856 }

◆ inside()

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

Inside() method for checks.

Definition at line 90 of file Volume.cxx.

91 {
92  if (!m_transform) {
93  return (volumeBounds()).inside(gp, tol);
94  }
95  Amg::Vector3D posInVolFrame((transform().inverse()) * gp);
96  return (volumeBounds()).inside(posInVolFrame, tol);
97 }

◆ interlinkLayers()

void Trk::TrackingVolume::interlinkLayers ( )
privateinherited

Register Next - Previous for Layers, set volumelink.

Definition at line 1143 of file TrackingVolume.cxx.

1144 {
1145  if (m_confinedLayers) {
1146  BinnedArraySpan<Trk::Layer* const> layers = m_confinedLayers->arrayObjects();
1147  // forward loop
1148  const Trk::Layer* lastLayer = nullptr;
1149  BinnedArraySpan<Trk::Layer* const>::iterator layerIter = layers.begin();
1150  for (; layerIter != layers.end(); ++layerIter) {
1151  if (*layerIter) {
1152  // register the layers
1153  (**layerIter).setBinUtility(confinedLayers()->binUtility()
1154  ? confinedLayers()->binUtility()
1155  : nullptr);
1156  (**layerIter).setPreviousLayer(lastLayer);
1157  // register the volume
1158  (**layerIter).encloseTrackingVolume(*this);
1159  }
1160  lastLayer = (*layerIter);
1161  }
1162  // backward loop
1163  lastLayer = nullptr;
1164  layerIter = layers.end();
1165  --layerIter;
1166  for (;; --layerIter) {
1167  if (*layerIter) {
1168  (**layerIter).setNextLayer(lastLayer);
1169  }
1170  lastLayer = (*layerIter);
1171  if (layerIter == layers.begin()) {
1172  break;
1173  }
1174  }
1175  }
1176 }

◆ isAlignable()

bool Trk::AlignableTrackingVolume::isAlignable ( ) const
inlinefinaloverridevirtual

Reimplemented from Trk::TrackingVolume.

Definition at line 74 of file AlignableTrackingVolume.h.

74  {
75  return true;
76 }

◆ layerAttempts()

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

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
inherited

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
inherited

Layer attempts - as provided by the LayerAttemptCreator.

◆ moveTV()

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

move the Tracking Volume

Definition at line 1374 of file TrackingVolume.cxx.

1375 {
1376 
1377  this->moveVolume(transform);
1378 
1379  // confined 'ordered' layers
1380  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1381  if (confLayers)
1382  for (Trk::Layer* clayIter : confLayers->arrayObjects()){
1383  clayIter->moveLayer(transform);
1384  }
1385 
1386  // confined 'unordered' layers
1387  Trk::ArraySpan<Trk::Layer* const> confArbLayers =
1388  confinedArbitraryLayers();
1389  if (!confArbLayers.empty()){
1390  for (Trk::Layer* calayIter : confArbLayers){
1391  calayIter->moveLayer(transform);
1392  }
1393  }
1394 
1395  // confined volumes
1396  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1397  if (confVolumes)
1398  // retrieve array objects and apply the transform
1399  for (Trk::TrackingVolume* cVolumesIter : confVolumes->arrayObjects()){
1400  (cVolumesIter)->moveTV(transform);
1401  }
1402 
1403  // confined unordered volumes
1404  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes =
1405  confinedDenseVolumes();
1406  if (!confDenseVolumes.empty())
1407  // retrieve array objects and apply the transform
1408  for (Trk::TrackingVolume* cVolumesIter : confDenseVolumes){
1409  cVolumesIter->moveTV(transform);
1410  }
1411 }

◆ moveVolume()

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

move Volume

Definition at line 1210 of file TrackingVolume.cxx.

1211 {
1212  if (m_transform) {
1213  Amg::Transform3D transf = shift * (*m_transform);
1214  this->m_transform = std::make_unique<Amg::Transform3D>(transf);
1215  } else {
1216  this->m_transform = std::make_unique<Amg::Transform3D>(shift);
1217  }
1218  this->m_center.store(
1219  std::make_unique<Amg::Vector3D>(m_transform->translation()));
1220 }

◆ nextLayer()

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

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

Definition at line 600 of file TrackingVolume.cxx.

604 {
605  const Trk::Layer* nextLayer = nullptr;
606  if (m_confinedLayers)
607  nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
608  // forward it in this case
609  if (!skipNavLayer)
610  return nextLayer;
611  // if only material or layers
612  if (nextLayer &&
613  (nextLayer->layerMaterialProperties() || nextLayer->surfaceArray()))
614  return nextLayer;
615  // try to get the next layer that has either material or sub surfaces
616  while (nextLayer && (!(nextLayer->layerMaterialProperties()) &&
617  !(nextLayer->surfaceArray())))
618  nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
619  return nextLayer;
620 }

◆ nextSubVolume()

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

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

Definition at line 786 of file TrackingVolume.cxx.

788 {
789  if (m_confinedVolumes)
790  return (m_confinedVolumes->nextObject(gp, mom));
791  return this;
792 }

◆ nextVolume()

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

Return the next volume along the navigation stream.

Definition at line 755 of file TrackingVolume.cxx.

758 {
759  // get the boundary surfaces & intersect them
760  const Trk::TrackingVolume* nVolume = nullptr;
761  // fix the direction once
762  bool forceDir = (pDir == Trk::alongMomentum || pDir == Trk::oppositeMomentum);
763  double dirScalor = (pDir == Trk::oppositeMomentum) ? -1. : 1.;
764  Amg::Vector3D cDir = dirScalor * dir;
765  double pathLength = 10e10;
766  // now loop through the and find the closest
767  const auto& bSurfaces = boundarySurfaces();
768  for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
769  // get the intersection soltuion
770  Trk::Intersection sfI =
771  bSurfaces[ib]->surfaceRepresentation().straightLineIntersection(
772  gp, cDir, forceDir, true);
773  if (sfI.valid &&
774  (sfI.pathLength * sfI.pathLength) < (pathLength * pathLength)) {
775  // assign the next Volume
776  Trk::PropDirection attachedDir =
777  sfI.pathLength > 0. ? Trk::alongMomentum : Trk::oppositeMomentum;
778  pathLength = sfI.pathLength;
779  nVolume = bSurfaces[ib]->attachedVolume(gp, cDir, attachedDir);
780  }
781  }
782  return nVolume;
783 }

◆ onVolumeBoundary()

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

show if you are on a boundary surface

◆ redoNavigation()

bool Trk::TrackingVolume::redoNavigation ( ) const
inherited

Boolean, if true navigation needs to be redone when hitting this volume.

◆ registerColorCode()

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

Register the color code.

◆ registerOutsideGlueVolumes()

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

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

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

Definition at line 1186 of file TrackingVolume.cxx.

1187 {
1188  m_outsideGlueVolumes.store(std::unique_ptr<Trk::GlueVolumesDescriptor>(gvd));
1189 }

◆ 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
inherited

Definition at line 1493 of file TrackingVolume.cxx.

1494 {
1495  msg << "[[ Trk::TrackingVolume ]] called: " << volumeName() << std::endl;
1496  msg << '\t' << '\t' << "# position (x,y,z) : " << center().x() << ", "
1497  << center().y() << ", " << center().z() << std::endl;
1498  msg << '\t' << '\t' << "# bounds : " << volumeBounds() << endmsg;
1499 }

◆ setMotherVolume()

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

set the MotherVolume

◆ sign()

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

sign the volume - the geometry builder has to do that

Definition at line 936 of file TrackingVolume.cxx.

938 {
939  // never overwrite what is already signed, that's a crime
940  if (m_geometrySignature == Trk::Unsigned) {
941  m_geometrySignature = geosign;
942  }
943  m_geometryType = geotype;
944 
945  // confined volumes
946  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
947  if (confVolumes) {
948  Trk::BinnedArraySpan<Trk::TrackingVolume* const> volumes =
949  confVolumes->arrayObjects();
950  for (const auto& volumesIter : volumes)
951  if (volumesIter)
952  volumesIter->sign(geosign, geotype);
953  }
954  // same procedure for the detached volumes
955  Trk::ArraySpan<Trk::DetachedTrackingVolume* const> confDetachedVolumes =
956  confinedDetachedVolumes();
957  if (!confDetachedVolumes.empty()) {
958  for (const auto& volumesIter : confDetachedVolumes) {
959  if (volumesIter) {
960  volumesIter->sign(geosign, geotype);
961  }
962  }
963  }
964  // confined dense volumes
965  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes =
966  confinedDenseVolumes();
967  if (!confDenseVolumes.empty()) {
968  for (const auto& volumesIter : confDenseVolumes) {
969  if (volumesIter) {
970  volumesIter->sign(geosign, geotype);
971  }
972  }
973  }
974 }

◆ synchronizeLayers()

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

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 1414 of file TrackingVolume.cxx.

1415 {
1416  // case a : Layers exist
1417  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
1418  if (confLayers) {
1419  for (Trk::Layer* clay : confLayers->arrayObjects())
1420  if (clay) {
1421  if (clay->surfaceRepresentation().type() ==
1422  Trk::SurfaceType::Cylinder &&
1423  !(center().isApprox(clay->surfaceRepresentation().center()))) {
1424  clay->resizeAndRepositionLayer(volumeBounds(), center(), envelope);
1425  } else {
1426  clay->resizeLayer(volumeBounds(), envelope);
1427  }
1428  } else
1429  msgstream << MSG::WARNING
1430  << " ---> found 0 pointer to layer in Volume [ "
1431  << volumeName() << " ], indicates problem." << endmsg;
1432  }
1433  // case b : container volume -> step down
1434  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
1435  if (confVolumes) {
1436  for (const auto& cVolumesIter : confVolumes->arrayObjects())
1437  cVolumesIter->synchronizeLayers(msgstream, envelope);
1438  }
1439 }

◆ 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 81 of file Volume.h.

82  { if (m_transform) return(*m_transform);
83  return Trk::s_idTransform;
84  }

◆ volumeBounds() [1/2]

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

Definition at line 103 of file Volume.h.

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

◆ volumeBounds() [2/2]

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

returns the volumeBounds()

Definition at line 97 of file Volume.h.

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

◆ volumeName()

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

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

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_alignedTV

std::unique_ptr<TrackingVolume> Trk::AlignableTrackingVolume::m_alignedTV = nullptr
private

Definition at line 61 of file AlignableTrackingVolume.h.

◆ m_alignment

std::unique_ptr<Amg::Transform3D> Trk::AlignableTrackingVolume::m_alignment = nullptr
private

Definition at line 60 of file AlignableTrackingVolume.h.

◆ m_binnedMaterial

std::unique_ptr<const BinnedMaterial> Trk::AlignableTrackingVolume::m_binnedMaterial = nullptr
private

Definition at line 62 of file AlignableTrackingVolume.h.

◆ m_boundarySurfaces

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

Definition at line 454 of file TrackingVolume.h.

◆ m_center

CxxUtils::CachedUniquePtr<Amg::Vector3D> Trk::Volume::m_center
protectedinherited

center position of the surface

Definition at line 77 of file Volume.h.

◆ m_colorCode

unsigned int Trk::TrackingVolume::m_colorCode
privateinherited

Color code for displaying.

Definition at line 481 of file TrackingVolume.h.

◆ m_confinedArbitraryLayers

const std::vector<Layer*>* Trk::TrackingVolume::m_confinedArbitraryLayers
privateinherited

< Additionally, Unordered Layers inside the Volume (we own them)

Definition at line 467 of file TrackingVolume.h.

◆ m_confinedDenseVolumes

const std::vector<TrackingVolume*>* Trk::TrackingVolume::m_confinedDenseVolumes
privateinherited

Definition at line 464 of file TrackingVolume.h.

◆ m_confinedDetachedVolumes

const std::vector<DetachedTrackingVolume*>* Trk::TrackingVolume::m_confinedDetachedVolumes
privateinherited

Additionally, Unordered subvolumes (we ownd them)

Definition at line 460 of file TrackingVolume.h.

◆ m_confinedLayers

LayerArray* Trk::TrackingVolume::m_confinedLayers
privateinherited

Array of Volumes inside the Volume.

Definition at line 456 of file TrackingVolume.h.

◆ m_confinedVolumes

TrackingVolumeArray* Trk::TrackingVolume::m_confinedVolumes
privateinherited

Detached subvolumes.

Definition at line 458 of file TrackingVolume.h.

◆ m_geometrySignature

GeometrySignature Trk::TrackingVolume::m_geometrySignature
privateinherited

defines how the Extrapolator propagates through this

Definition at line 476 of file TrackingVolume.h.

◆ m_geometryType

GeometryType Trk::TrackingVolume::m_geometryType
privateinherited

Definition at line 478 of file TrackingVolume.h.

◆ m_layerAttemptsCalculator

LayerAttemptsCalculator* Trk::TrackingVolume::m_layerAttemptsCalculator
privateinherited

The Signature done by the GeometryBuilder.

Definition at line 473 of file TrackingVolume.h.

◆ m_motherVolume

const TrackingVolume* Trk::TrackingVolume::m_motherVolume
privateinherited

mother volume of this volume

boundary Surfaces

Definition at line 451 of file TrackingVolume.h.

◆ m_name

std::string Trk::TrackingVolume::m_name
privateinherited

Volume name for debug reasons.

Definition at line 480 of file TrackingVolume.h.

◆ m_outsideGlueVolumes

CxxUtils::CachedUniquePtrT<GlueVolumesDescriptor> Trk::TrackingVolume::m_outsideGlueVolumes
privateinherited

provided the number of layer attempts

Definition at line 470 of file TrackingVolume.h.

◆ m_redoNavigation

bool Trk::TrackingVolume::m_redoNavigation
privateinherited

Navigation boolean.

If true navigation needs to be redone when entering this volume

Definition at line 482 of file TrackingVolume.h.

◆ m_sampleID

int Trk::AlignableTrackingVolume::m_sampleID {}
private

Definition at line 63 of file AlignableTrackingVolume.h.

◆ m_transform

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

HepGeom::Transform3D.

Definition at line 76 of file Volume.h.

◆ m_volumeBounds

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

the volumeBounds

Definition at line 78 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
Trk::TrackingVolume::m_confinedVolumes
TrackingVolumeArray * m_confinedVolumes
Detached subvolumes.
Definition: TrackingVolume.h:458
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition: trapping_fp.h:24
Trk::TrackingVolume::createBoundarySurfaces
void createBoundarySurfaces()
Create Boundary Surface.
Definition: TrackingVolume.cxx:996
Trk::SubtractedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: SubtractedVolumeBounds.h:124
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:600
Trk::Intersection
Definition: Intersection.h:24
Trk::BinnedArray::binUtility
virtual const BinUtility * binUtility() const =0
Return the BinUtility.
Trk::TrackingVolume::moveVolume
void moveVolume(Amg::Transform3D &shift)
move Volume
Definition: TrackingVolume.cxx:1210
Trk::TrackingVolume::m_layerAttemptsCalculator
LayerAttemptsCalculator * m_layerAttemptsCalculator
The Signature done by the GeometryBuilder.
Definition: TrackingVolume.h:473
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:623
Trk::Volume::m_center
CxxUtils::CachedUniquePtr< Amg::Vector3D > m_center
center position of the surface
Definition: Volume.h:77
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:78
Trk::TrackingVolume::m_confinedDenseVolumes
const std::vector< TrackingVolume * > * m_confinedDenseVolumes
Definition: TrackingVolume.h:464
Trk::Intersection::pathLength
double pathLength
Definition: Intersection.h:26
module_driven_slicing.layers
layers
Definition: module_driven_slicing.py:114
Trk::NavigationLayer
Definition: NavigationLayer.h:41
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
PlotCalibFromCool.ib
ib
Definition: PlotCalibFromCool.py:419
Trk::SubtractedPlaneLayer
Definition: SubtractedPlaneLayer.h:34
Trk::BinnedArray::object
virtual T * object(const Amg::Vector2D &lp) const =0
Returns the pointer to the templated class object from the BinnedArray, it returns 0 if not defined,...
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:454
Trk::SubtractedPlaneLayer::moveLayer
virtual void moveLayer(Amg::Transform3D &shift) override final
move the Layer
Definition: SubtractedPlaneLayer.cxx:72
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
Trk::TrackingVolume::m_confinedLayers
LayerArray * m_confinedLayers
Array of Volumes inside the Volume.
Definition: TrackingVolume.h:456
Trk::DiscSurface
Definition: DiscSurface.h:54
python.RingerConstants.Layer
Layer
Definition: RingerConstants.py:42
Trk::BoundaryPlaneSurface
Definition: BoundaryPlaneSurface.h:38
Trk::CombinedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: CombinedVolumeBounds.h:128
TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT
#define TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT
Definition: LayerIndex.h:19
Trk::TrackingVolume::m_confinedArbitraryLayers
const std::vector< Layer * > * m_confinedArbitraryLayers
< Additionally, Unordered Layers inside the Volume (we own them)
Definition: TrackingVolume.h:467
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.
Trk::TrackingVolume::m_confinedDetachedVolumes
const std::vector< DetachedTrackingVolume * > * m_confinedDetachedVolumes
Additionally, Unordered subvolumes (we ownd them)
Definition: TrackingVolume.h:460
Trk::TrackingVolume::cloneTV
TrackingVolume * cloneTV(Amg::Transform3D &transform) const
clone at new position
Definition: TrackingVolume.cxx:1222
Trk::PropDirection
PropDirection
Definition: PropDirection.h:19
Trk::BoundaryDiscSurface
Definition: BoundaryDiscSurface.h:40
A
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
Trk::AlignableTrackingVolume::m_alignedTV
std::unique_ptr< TrackingVolume > m_alignedTV
Definition: AlignableTrackingVolume.h:61
Trk::Layer::surfaceRepresentation
virtual const Surface & surfaceRepresentation() const =0
Transforms the layer into a Surface representation for extrapolation.
Trk::BoundarySubtractedPlaneSurface
Definition: BoundarySubtractedPlaneSurface.h:39
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: DetachedTrackingVolume.h:34
Trk::TrackingVolume::confinedArbitraryLayers
ArraySpan< Layer const *const > confinedArbitraryLayers() const
Return the confined subLayer array.
Trk::AlignableTrackingVolume::m_alignment
std::unique_ptr< Amg::Transform3D > m_alignment
Definition: AlignableTrackingVolume.h:60
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
MuonR4::inverse
CalibratedSpacePoint::Covariance_t inverse(const CalibratedSpacePoint::Covariance_t &mat)
Inverts the parsed matrix.
Definition: MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx:65
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_geometrySignature
GeometrySignature m_geometrySignature
defines how the Extrapolator propagates through this
Definition: TrackingVolume.h:476
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::PlaneLayer
Definition: PlaneLayer.h:40
Trk::Volume::clone
virtual Volume * clone() const
Pseudo-constructor.
Definition: Volume.cxx:78
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:175
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:86
Trk::Surface::materialLayer
const Trk::Layer * materialLayer() const
return the material Layer
Trk::TrackingVolume::boundarySurfaces
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > & boundarySurfaces()
Method to return the BoundarySurfaces.
Definition: TrackingVolume.cxx:977
Trk::PlaneLayer::moveLayer
virtual void moveLayer(Amg::Transform3D &shift) override final
move the Layer
Definition: PlaneLayer.cxx:83
Trk::LayerIndex::value
int value() const
layerIndex expressed in an integer
Definition: LayerIndex.h:71
Trk::Unsigned
@ Unsigned
Definition: GeometrySignature.h:33
Trk::Volume::boundarySurfaceAccessor
ObjectAccessor boundarySurfaceAccessor(const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool forceInside=false) const
Provide accessor for BoundarySurfaces.
Definition: Volume.cxx:100
Trk::AlignableTrackingVolume::m_binnedMaterial
std::unique_ptr< const BinnedMaterial > m_binnedMaterial
Definition: AlignableTrackingVolume.h:62
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:623
Trk::BinUtility
Definition: BinUtility.h:39
Trk::CylinderLayer
Definition: CylinderLayer.h:43
Trk::ConstSharedPtrSpan
Definition: TrackingVolume.h:67
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::BinnedArray::arrayObjects
virtual BinnedArraySpan< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
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:1374
Trk::Volume::transform
const Amg::Transform3D & transform() const
Return methods for geometry transform.
Definition: Volume.h:81
Trk::TrackingVolume::m_geometryType
GeometryType m_geometryType
Definition: TrackingVolume.h:478
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
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:18
Trk::DiscLayerAttemptsCalculator
Definition: DiscLayerAttemptsCalculator.h:23
Trk::VolumeBounds::decomposeToSurfaces
virtual const std::vector< const Trk::Surface * > * decomposeToSurfaces(const Amg::Transform3D &transform)=0
Method to decompose the Bounds into Surfaces, the Volume can turn them into BoundarySurfaces.
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
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:755
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:155
DeMoScan.first
bool first
Definition: DeMoScan.py:536
Trk::SubtractedVolumeBounds
Definition: SubtractedVolumeBounds.h:40
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:97
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::CylinderLayerAttemptsCalculator
Definition: CylinderLayerAttemptsCalculator.h:24
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
HepGeom::Transform3D.
Definition: Volume.h:76
Trk::CylinderLayer::moveLayer
virtual void moveLayer(Amg::Transform3D &shift) override final
move the Layer
Definition: CylinderLayer.cxx:186
Trk::FullIntersection
Class extension to return the object, a represenation & the result.
Definition: Intersection.h:64
Trk::SubtractedCylinderLayer::moveLayer
virtual void moveLayer(Amg::Transform3D &shift) override final
move the Layer
Definition: SubtractedCylinderLayer.cxx:75
Trk::BinnedArray
Definition: BinnedArray.h:38
Trk::CombinedVolumeBounds
Definition: CombinedVolumeBounds.h:42
Trk::AlignableTrackingVolume::m_sampleID
int m_sampleID
Definition: AlignableTrackingVolume.h:63
Trk::TrackingVolume::m_outsideGlueVolumes
CxxUtils::CachedUniquePtrT< GlueVolumesDescriptor > m_outsideGlueVolumes
provided the number of layer attempts
Definition: TrackingVolume.h:470
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Trk::Volume
Definition: Volume.h:35
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Trk::TrackingVolume
Definition: TrackingVolume.h:121
Trk::TrackingVolume::associatedLayer
const Layer * associatedLayer(const Amg::Vector3D &gp) const
Return the associated Layer.
Definition: TrackingVolume.cxx:564
Trk::BinnedArraySpan
std::span< T > BinnedArraySpan
Definition: BinnedArray.h:34
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:73
Trk::Layer::layerIndex
const LayerIndex & layerIndex() const
get the layerIndex
Generated on Wed Apr 23 2025 22:06:02 for ATLAS Offline Software by   doxygen 1.8.18