Trk::AlignableTrackingVolume Class Reference

Base Class for a navigation object (active) in the Calo realm. More...

#include <AlignableTrackingVolume.h>

Inheritance diagram for Trk::AlignableTrackingVolume:

Collaboration diagram for Trk::AlignableTrackingVolume:

Public Member Functions
	AlignableTrackingVolume ()=default
	Default Constructor.
virtual	~AlignableTrackingVolume () override=default
	AlignableTrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const BinnedMaterial &matprop, int sampleID, const std::string &volumeName="undefined")
	Constructor.
const TrackingVolume *	alignedTrackingVolume () const
	returns the alignedTrackingVolume
int	identify () const
	returns the id
const BinnedMaterial *	binnedMaterial () const
	access to binned material
virtual bool	isAlignable () const override final
const Layer *	associatedLayer (const Amg::Vector3D &gp) const
	Return the associated Layer.
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.
const Layer *	entryLayer (const Amg::Vector3D &gp, const Amg::Vector3D &dir) const
	Return the entry Layer to a TrackingVolume depending on the entry point.
const Layer *	exitLayer (const Amg::Vector3D &gp, const Amg::Vector3D &dir) const
	Return the exit Layer from a TrackingVolume.
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:
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.
const TrackingVolume *	associatedSubVolume (const Amg::Vector3D &gp) const
	Return the associated sub Volume, returns THIS if no subVolume exists.
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.
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.
std::vector< const DetachedTrackingVolume * >	assocDetachedSubVolumes (const Amg::Vector3D &gp, double tol) const
	Return the associated detached subvolumes.
unsigned int	layerAttempts (BoundarySurfaceFace exitFace) const
	Layer attempts - as provided by the LayerAttemptCreator.
unsigned int	maxLayerAttempts () const
	Layer attempts - as provided by the LayerAttemptCreator.
const LayerArray *	confinedLayers () const
	Return the subLayer array.
LayerArray *	confinedLayers ()
	Return the subLayer array.
ArraySpan< Layer const *const >	confinedArbitraryLayers () const
	Return the confined subLayer array.
ArraySpan< Layer *const >	confinedArbitraryLayers ()
	Return the confined subLayer array.
const LayerArray *	checkoutConfinedLayers () const
	Return the subLayerarray including the ownership.
const TrackingVolumeArray *	confinedVolumes () const
	Return the subLayer array.
TrackingVolumeArray *	confinedVolumes ()
	Return the subLayer array.
ArraySpan< DetachedTrackingVolume const *const >	confinedDetachedVolumes () const
	Return detached subVolumes - not the ownership.
ArraySpan< DetachedTrackingVolume *const >	confinedDetachedVolumes ()
ArraySpan< TrackingVolume const *const >	confinedDenseVolumes () const
	Return unordered subVolumes - not the ownership.
ArraySpan< TrackingVolume *const >	confinedDenseVolumes ()
const std::string &	volumeName () const
	Returns the VolumeName - for debug reason, might be depreciated later.
std::vector< std::shared_ptr< BoundarySurface< TrackingVolume > > > &	boundarySurfaces ()
	Method to return the BoundarySurfaces.
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.
const BoundarySurface< TrackingVolume > *	boundarySurface (const ObjectAccessor::value_type &oa) const
	Get the BoundarySurface to the appointed Accessor state.
template<class T>
bool	onVolumeBoundary (const T &pars) const
	show if you are on a boundary surface
void	registerOutsideGlueVolumes (GlueVolumesDescriptor *gvd)
	Register the outside glue volumes - ordering is in the TrackingVolume Frame:
GlueVolumesDescriptor &	glueVolumesDescriptor ()
const GlueVolumesDescriptor &	glueVolumesDescriptor () const
void	sign (GeometrySignature signat, GeometryType gtype=Static)
	sign the volume - the geometry builder has to do that
GeometrySignature	geometrySignature () const
	return the Signature
GeometryType	geometryType () const
	return the Signature
void	registerColorCode (unsigned int icolor)
	Register the color code.
unsigned int	colorCode () const
	Get the color code.
const TrackingVolume *	getMotherVolume () const
	Return the MotherVolume - if it exists.
void	setMotherVolume (const TrackingVolume *mvol)
	set the MotherVolume
void	moveVolume (Amg::Transform3D &shift)
	move Volume
void	addMaterial (const Material &mat, float fact=1.)
	add Material
void	screenDump (MsgStream &msg) const
virtual Volume *	clone () const
	polymorpic deep copy
const Amg::Transform3D &	transform () const
	Return methods for geometry transform.
const Amg::Vector3D &	center () const
	returns the center of the volume
const VolumeBounds &	volumeBounds () const
	returns the volumeBounds()
VolumeBounds &	volumeBounds ()
bool	inside (const Amg::Vector3D &gp, double tol=0.) const
	Inside() method for checks.
ObjectAccessor	boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool forceInside=false) const
	Provide accessor for BoundarySurfaces.
std::unique_ptr< Material >	scale (float sf) const
	scaling method
float	zOverAtimesRho () const
	access to members
float	x0 () const
float	averageZ () const
std::string	toString () const
	spit out as a string

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)
Amg::Vector3D	m_center = Trk::s_origin
	center position of the surface
std::shared_ptr< VolumeBounds >	m_volumeBounds = nullptr
	the volumeBounds

Private Member Functions
void	indexContainedStaticLayers (GeometrySignature geoSig, int &offset)
	reIndex the static layers of the TrackingVolume
void	indexContainedMaterialLayers (GeometrySignature geoSig, int &offset)
	reIndex the material layers of the TrackingVolume
void	createBoundarySurfaces ()
	Create Boundary Surface.
void	createLayerAttemptsCalculator ()
	Create Layer Attempts Caluclator.
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
void	synchronizeLayers (MsgStream &msgstream, double envelope=1.)
	method to synchronize the layers with potentially updated volume bounds:
void	interlinkLayers ()
	Register Next - Previous for Layers, set volumelink.
void	moveTV (Amg::Transform3D &transform)
	move the Tracking Volume

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.

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

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	(	std::unique_ptr< Amg::Transform3D >	htrans,
		std::shared_ptr< VolumeBounds >	volbounds,
		const BinnedMaterial &	matprop,
		int	sampleID,
		const std::string &	volumeName = "undefined" )

Constructor.

Definition at line 15 of file AlignableTrackingVolume.cxx.

    : Trk::TrackingVolume(std::move(htrans), std::move(volbounds), matprop, nullptr, nullptr, volumeName),
      m_binnedMaterial(matprop),
      m_sampleID(sampleID){}

Member Function Documentation

addMaterial()

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

inherited

add Material

Definition at line 736 of file TrackingVolume.cxx.

{
  // assume the scaling factor refers to the volume scaling
  float flin = pow(fact, 0.33);
  // average X0
  double invX0 = X0 > 0. ? 1. / X0 : 0.;
  double sum_invX0 = invX0 + flin / mprop.X0;
  X0 = 1. / sum_invX0;
  // average L0
  double invL0 = L0 > 0. ? 1. / L0 : 0.;
  double sum_invL0 = invL0 + flin / mprop.L0;
  L0 = 1. / sum_invL0;
  // add density
  float rho1 = rho;
  rho += fact * mprop.rho;
  // averageZ
  float n1 = Z > 0. ? rho1 / Z : 0.;
  float n2 = fact * mprop.rho / mprop.Z;
  Z = rho / (n1 + n2);
  // averageA
  n1 = A > 0. ? rho1 / A : 0.;
  n2 = fact * mprop.rho / mprop.A;
  A = rho / (n1 + n2);
  // zOverAtimesRho
  zOaTr = Z / A * rho;
  // mean energy loss (linear scaling)
  dEdX += flin * mprop.dEdX;
}

alignedTrackingVolume()

const TrackingVolume * Trk::AlignableTrackingVolume::alignedTrackingVolume

(

)

const

returns the alignedTrackingVolume

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

{
  auto currVols = std::vector<const Trk::DetachedTrackingVolume*>();
 
  Trk::ArraySpan<const Trk::DetachedTrackingVolume* const> detVols =
    confinedDetachedVolumes();
  if (!detVols.empty()) {
    for (const auto *detVol : detVols) {
      if (detVol->trackingVolume()->inside(gp, tol)){
        currVols.push_back(detVol);
      }
    }
  }
  return currVols;
}

associatedLayer() [1/2]

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

inherited

Definition at line 400 of file TrackingVolume.cxx.

{
  // confined layers
  if (m_confinedLayers){
    return (confinedLayers()->object(gp));
  }
  // confined arbitrary
  if (m_confinedArbitraryLayers) {
    for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
      if (confinedArbitraryLayer->isOnLayer(gp)){
        return confinedArbitraryLayer;
      }
    }
  }
  return nullptr;
}

associatedLayer() [2/2]

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

inherited

Return the associated Layer.

Definition at line 382 of file TrackingVolume.cxx.

{
  // confined layers
  if (m_confinedLayers){
    return (confinedLayers()->object(gp));
  }
  // confined arbitrary
  if (m_confinedArbitraryLayers) {
    for (auto* confinedArbitraryLayer : *m_confinedArbitraryLayers){
      if (confinedArbitraryLayer->isOnLayer(gp)){
        return confinedArbitraryLayer;
      }
    }
  }
  return nullptr;
}

associatedSubVolume() [1/2]

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

inherited

Definition at line 556 of file TrackingVolume.cxx.

{
  if (m_confinedVolumes){
    return (m_confinedVolumes->object(gp));
  }
 
  if (m_confinedDetachedVolumes) {
    for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
      if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
        return confinedDetachedVolume->trackingVolume();
      }
    }
  }
 
  if (m_confinedDenseVolumes) {
    for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
      if (confinedDenseVolume->inside(gp, 0.001)){
        return confinedDenseVolume;
      }
    }
  }
 
  return this;
}

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

{
  if (m_confinedVolumes){
    return (m_confinedVolumes->object(gp));
  }
 
  if (m_confinedDetachedVolumes) {
    for (auto *confinedDetachedVolume : *m_confinedDetachedVolumes) {
      if (confinedDetachedVolume->trackingVolume()->inside(gp, 0.001)){
        return confinedDetachedVolume->trackingVolume();
      }
    }
  }
 
  if (m_confinedDenseVolumes) {
    for (auto *confinedDenseVolume : *m_confinedDenseVolumes){
      if (confinedDenseVolume->inside(gp, 0.001)){
        return confinedDenseVolume;
      }
    }
  }
 
  return this;
}

averageZ()

float Trk::Material::averageZ ( ) const

inlineinherited

Definition at line 228 of file Material.h.

{ return (*this).Z; }

binnedMaterial()

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

inline

access to binned material

Definition at line 68 of file AlignableTrackingVolume.h.

                                                                           {
  return &m_binnedMaterial;
}

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

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

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.

{
  if (!m_transform) {
    return Trk::ObjectAccessor(
      volumeBounds().boundarySurfaceAccessor(gp, dir, forceInside));
  }
  return Trk::ObjectAccessor(volumeBounds().boundarySurfaceAccessor(
    transform().inverse() * gp, dir, forceInside));
}

boundarySurfaces() [1/2]

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

inherited

Method to return the BoundarySurfaces.

Definition at line 809 of file TrackingVolume.cxx.

{
  return m_boundarySurfaces;
}

boundarySurfaces() [2/2]

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

inherited

Definition at line 815 of file TrackingVolume.cxx.

{
  return Trk::ConstSharedPtrSpan<Trk::BoundarySurface<Trk::TrackingVolume>>(
    m_boundarySurfaces);
}

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

    {
      return m_center;
    }

checkoutConfinedLayers()

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

inherited

Return the subLayerarray including the ownership.

Definition at line 1003 of file TrackingVolume.cxx.

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

clone()

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

virtualinherited

polymorpic deep copy

Definition at line 60 of file Volume.cxx.

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

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

{
  // use the distance solution for assigning the layer
  Trk::DistanceSolution distSolToPrevious =
    first.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
  Trk::DistanceSolution distSolToNext =
    second.surfaceRepresentation().straightLineDistanceEstimate(pos, dir);
  // find out which one
  return (distSolToPrevious.absClosest() < distSolToNext.absClosest()
            ? &first
            : &second);
}

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

{
  // the layer candidates to check
  std::vector<const Layer*> layerCandidates;
 
  // ---------------- BOUNDARY LAYER SECTION (only for mapping) ----------
  if (pDir == mappingMode) {
    const auto& bSurfaces = boundarySurfaces();
    for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
      if (bSurfaces[ib]->surfaceRepresentation().materialLayer()){
        layerCandidates.push_back(bSurfaces[ib]->surfaceRepresentation().materialLayer());
      }
    }
  }
  // ---------------- CONFINED LAYER SECTION --------------
  if (m_confinedLayers) {
    // the associated layer
    const Trk::Layer* assocLayer = associatedLayer(gp);
    const Trk::Layer* previousMatLayer = nullptr;
    const Trk::Layer* nextMatLayer = nullptr;
    // if the associated layer is a navigation layer - get the previous and next
    // from this one
    const Trk::NavigationLayer* navLayer =
      dynamic_cast<const Trk::NavigationLayer*>(assocLayer);
    if (navLayer) {
      // get previous / next
      previousMatLayer = navLayer->previousLayer();
      nextMatLayer = navLayer->nextLayer();
      if (previousMatLayer){
        layerCandidates.push_back(previousMatLayer);
      }
      if (nextMatLayer){
        layerCandidates.push_back(nextMatLayer);
      }
    } else{
      layerCandidates.push_back(assocLayer);
    }
  }
  // --- solve for the layer candidates ---------------------
  //
  Trk::Intersection laySurfIntersection(Amg::Vector3D(0., 0., 0.), 10e10, false);
  // layer candidates found - continue
  if (!layerCandidates.empty()) {
    const Layer* cLayer = nullptr;
    // iterate through and chose
    for (auto& lcIter : layerCandidates) {
      // only the forceFwd solution is possible here
      bool forceDir = (pDir == alongMomentum || pDir == oppositeMomentum);
      double dirScalor = (pDir == oppositeMomentum) ? -1. : 1.;
      // get the intersection soltuion
      Trk::Intersection sfI =
        (*lcIter).surfaceRepresentation().straightLineIntersection(
          gp, dirScalor * dir, forceDir, bchk);
      if (sfI.valid &&
          (sfI.pathLength * sfI.pathLength) <
            (laySurfIntersection.pathLength * laySurfIntersection.pathLength)) {
        laySurfIntersection = sfI;
        cLayer = lcIter;
      }
    }
    // now return the pair: in case of a valid intersection, or if no mapping
    // mode is chosen
    if (cLayer){
      return Trk::LayerIntersection<Amg::Vector3D>(
        laySurfIntersection,
        cLayer,
        &(cLayer->surfaceRepresentation()),
        nullptr,
        pDir);
    }
  }
  // mapping mode chosen, but no valid intersection yet
  const Trk::TrackingVolume* nVolume = nextVolume(gp, dir, pDir);
 
  // forward the next Volume solution or a 0 solution
  return (nVolume && nVolume != this)
           ? nVolume->closestMaterialLayer(gp, dir, pDir, bchk)
           : Trk::LayerIntersection<Amg::Vector3D>(
               laySurfIntersection, nullptr, nullptr, nullptr, pDir);
}

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

{
  // confined 'ordered' layers
  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
  if (confLayers) {
    std::span<Trk::Layer* const> layers = confLayers->arrayObjects();
    for (const auto& clayIter : layers) {
      if (&(*clayIter) != nullptr){
        clayIter->compactify(cSurfaces, tSurfaces);
      }
      else{
        std::cout << "WARNING: Attempt to compactify nullptr layer in volume : "
                  << volumeName() << std::endl;
      }
    }
  }
  // confined 'unordered' layers
  Trk::ArraySpan<Trk::Layer* const> confArbLayers = confinedArbitraryLayers();
  if (!confArbLayers.empty()) {
    for (const auto& calayIter : confArbLayers) {
      if (calayIter != nullptr) {
        calayIter->compactify(cSurfaces, tSurfaces);
      } else {
        std::cout << "WARNING: Attempt to compactify nullptr layer."
                  << std::endl;
      }
    }
  }
  // confined volumes
  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
  if (confVolumes) {
    std::span<Trk::TrackingVolume* const> volumes =
      confVolumes->arrayObjects();
    for (const auto& cVolumesIter : volumes) {
      cVolumesIter->compactify(cSurfaces, tSurfaces);
    }
  }
  // confined unordered volumes
  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes = confinedDenseVolumes();
  if (!confDenseVolumes.empty()){
    for (const auto& cVolumesIter : (confDenseVolumes)) {
      cVolumesIter->compactify(cSurfaces, tSurfaces);
    }
  }
 
  // detached volumes if any
  if (m_confinedDetachedVolumes){
    for (const auto& cdVolumesIter : (*m_confinedDetachedVolumes)) {
      cdVolumesIter->compactify(cSurfaces, tSurfaces);
    }
  }
}

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

{
  // prepare the BoundarySurfaces
  m_boundarySurfaces =
    std::vector<std::shared_ptr<Trk::BoundarySurface<Trk::TrackingVolume>>>();
  // transform Surfaces To BoundarySurfaces
  std::vector<std::unique_ptr<Trk::Surface>> surfaces =
    Trk::Volume::volumeBounds().decomposeToSurfaces(transform());
  auto surfIter = surfaces.begin();
 
  // counter to flip the inner/outer position for Cylinders
  unsigned int sfCounter = 0;
  unsigned int sfNumber = surfaces.size();
 
  // memory optimisation
  m_boundarySurfaces.reserve(sfNumber + 1);
 
  // identify Subtracted/CombinedVolumes
  const Trk::SubtractedVolumeBounds* subtrVol =
    dynamic_cast<const Trk::SubtractedVolumeBounds*>(
      &(Trk::Volume::volumeBounds()));
  const Trk::CombinedVolumeBounds* combVol =
    dynamic_cast<const Trk::CombinedVolumeBounds*>(
      &(Trk::Volume::volumeBounds()));
  bool subtr = (subtrVol) ? 1 : 0;
  bool comb = (combVol) ? 1 : 0;
 
  if (!subtr && !comb) {
    const Trk::SimplePolygonBrepVolumeBounds* spbVol =
      dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
        &(Trk::Volume::volumeBounds()));
 
    for (; surfIter != surfaces.end(); ++surfIter) {
      sfCounter++;
 
      Trk::TrackingVolume* in = this;
      Trk::TrackingVolume* out = nullptr;
 
      // ST update: subtracted surfaces may appear in 'simple' volumes
      // (SimplePolygonBrep...)
      const Trk::SubtractedPlaneSurface* spsf =
        dynamic_cast<const Trk::SubtractedPlaneSurface*>((*surfIter).get());
      const Trk::PlaneSurface* psf =
        dynamic_cast<const Trk::PlaneSurface*>((*surfIter).get());
      if (spsf) {
        if (spbVol && sfCounter == 1) {
          in = nullptr;
          out = this;
        }
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
              in, out, *spsf));
        continue;
      }
      if (psf) {
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundaryPlaneSurface<Trk::TrackingVolume>>(in, out, *psf));
        continue;
      }
 
      const Trk::DiscSurface* dsf =
        dynamic_cast<const Trk::DiscSurface*>((*surfIter).get());
      if (dsf) {
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundaryDiscSurface<Trk::TrackingVolume>>(in, out, *dsf));
        continue;
      }
 
      const Trk::SubtractedCylinderSurface* scsf =
        dynamic_cast<const Trk::SubtractedCylinderSurface*>((*surfIter).get());
      const Trk::CylinderSurface* csf =
        dynamic_cast<const Trk::CylinderSurface*>((*surfIter).get());
      if (scsf) {
        Trk::TrackingVolume* inner =
          (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
        Trk::TrackingVolume* outer = (inner) ? nullptr : this;
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(inner, outer, *scsf));
        continue;
      }
      if (csf) {
        Trk::TrackingVolume* inner =
          (sfCounter == 4 && sfNumber > 3) ? nullptr : this;
        Trk::TrackingVolume* outer = (inner) ? nullptr : this;
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundaryCylinderSurface<Trk::TrackingVolume>>(
              inner, outer, *csf));
        continue;
      }
    }
 
  } else {
    const std::vector<bool> bOrient =
      subtrVol ? subtrVol->boundsOrientation() : combVol->boundsOrientation();
 
    for (; surfIter != surfaces.end(); ++surfIter) {
      Trk::TrackingVolume* in = bOrient[sfCounter] ? this : nullptr;
      Trk::TrackingVolume* out = bOrient[sfCounter] ? nullptr : this;
      sfCounter++;
 
      const Trk::SubtractedPlaneSurface* psf =
        dynamic_cast<const Trk::SubtractedPlaneSurface*>((*surfIter).get());
      if (psf) {
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(
              in, out, *psf));
        continue;
      }
 
      const Trk::SubtractedCylinderSurface* csf =
        dynamic_cast<const Trk::SubtractedCylinderSurface*>((*surfIter).get());
      if (csf) {
        m_boundarySurfaces.push_back(
          std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(
              in, out, *csf));
        continue;
      }
    }
  }
}

createLayerAttemptsCalculator()

void Trk::TrackingVolume::createLayerAttemptsCalculator ( )

privateinherited

Create Layer Attempts Caluclator.

Definition at line 950 of file TrackingVolume.cxx.

{
  // check whether there's a static array
  if (m_confinedLayers) {
    // BinUtility
    const Trk::BinUtility* binUtility = m_confinedLayers->binUtility();
    if (binUtility) {
      if (binUtility->binningValue() == Trk::binR){
        m_layerAttemptsCalculator = std::make_unique<Trk::CylinderLayerAttemptsCalculator>(1, 5);
      }
      if (binUtility->binningValue() == Trk::binZ){
        m_layerAttemptsCalculator = std::make_unique<Trk::DiscLayerAttemptsCalculator>(1, 5);
      }
    }
  }
}

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.

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

{
  if (!m_outsideGlueVolumes) {
    m_outsideGlueVolumes.store(std::make_unique<Trk::GlueVolumesDescriptor>());
  }
  return (*m_outsideGlueVolumes);
}

glueVolumesDescriptor() [2/2]

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

inherited

Definition at line 1025 of file TrackingVolume.cxx.

{
  if (!m_outsideGlueVolumes) {
    m_outsideGlueVolumes.set(std::make_unique<Trk::GlueVolumesDescriptor>());
  }
  return (*m_outsideGlueVolumes);
}

identify()

int Trk::AlignableTrackingVolume::identify ( ) const

inline

returns the id

Definition at line 64 of file AlignableTrackingVolume.h.

                                                   {
  return m_sampleID;
}

indexContainedMaterialLayers()

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

privateinherited

reIndex the material layers of the TrackingVolume

Definition at line 689 of file TrackingVolume.cxx.

{
  // the offset gets increased internally
  // the static layers first and check if they have surfaces with material
  // layers that need index
  if (m_confinedLayers) {
    std::span<Trk::Layer * const> layers = confinedLayers()->arrayObjects();
    for (Trk::Layer* layerIter : layers) {
      // only index the material layers & only those that have not yet been
      // singed
      if (layerIter) {
        Trk::SurfaceArray* surfArray = layerIter->surfaceArray();
        if (surfArray) {
          std::span<Trk::Surface * const> layerSurfaces = surfArray->arrayObjects();
          // loop over the surfaces - there can be 0 entries
          for (Trk::Surface* const laySurf : layerSurfaces) {
            Trk::MaterialLayer* materialLayer = laySurf ? laySurf->materialLayer() : nullptr;
            if (materialLayer && materialLayer->layerIndex().value() < 0) {
              // sign only those with material properties - rest goes to 0
              Trk::LayerIndex layIndex =
                materialLayer->layerMaterialProperties()
                  ? Trk::LayerIndex(int(geoSig) *
                                      TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT +
                                    (++offset))
                  : Trk::LayerIndex(0);
              // now register the index
              materialLayer->registerLayerIndex(layIndex);
            }
          }
        }
      }
    }
  }
 
  // step down the hierarchy to the contained volumes and index those
  // ------------------------
  if (confinedVolumes()) {
    std::span<Trk::TrackingVolume * const> volumes = confinedVolumes()->arrayObjects();
    for (Trk::TrackingVolume* volumesIter : volumes) {
      if (volumesIter)
        volumesIter->indexContainedMaterialLayers(geoSig, offset);
    }
  }
}

indexContainedStaticLayers()

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

privateinherited

reIndex the static layers of the TrackingVolume

Definition at line 642 of file TrackingVolume.cxx.

{
  // the offset gets increased internally
  // the static layers first
  // ------------------------------------------------------------------
  if (m_confinedLayers) {
    std::span<Trk::Layer* const> layers = confinedLayers()->arrayObjects();
    for (Trk::Layer* layerptr : layers) {
      // only index the material layers & only those that have not yet been
      // singed
      if (layerptr && layerptr->layerIndex().value() < 0) {
        // sign only those with material properties - rest goes to 0
        Trk::LayerIndex layIndex =
          layerptr->layerMaterialProperties()
            ? Trk::LayerIndex(
                int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset))
            : Trk::LayerIndex(0);
        // now register the index
        layerptr->registerLayerIndex(layIndex);
      }
    }
  }
 
  // the boundary surface layer
  auto& bSurfaces = boundarySurfaces();
  for (const auto& bsIter : bSurfaces) {
    Trk::MaterialLayer* mLayer = bsIter->surfaceRepresentation().materialLayer();
    if (mLayer && mLayer->layerIndex().value() < 0.) {
      Trk::LayerIndex layIndex = Trk::LayerIndex(
        int(geoSig) * TRKDETDESCR_GEOMETRYSIGNATUREWEIGHT + (++offset));
      mLayer->registerLayerIndex(layIndex);
    }
  }
 
  // step down the hierarchy to the contained volumes and index those
  // ------------------------
  if (confinedVolumes()) {
    std::span<Trk::TrackingVolume* const > volumes = confinedVolumes()->arrayObjects();
    for (const auto& volumesIter : volumes) {
      if (volumesIter)
        volumesIter->indexContainedStaticLayers(geoSig, offset);
    }
  }
}

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.

{
  if (!m_transform) {
    return (volumeBounds()).inside(gp, tol);
  }
  Amg::Vector3D posInVolFrame((transform().inverse()) * gp);
  return (volumeBounds()).inside(posInVolFrame, tol);
}

interlinkLayers()

void Trk::TrackingVolume::interlinkLayers ( )

privateinherited

Register Next - Previous for Layers, set volumelink.

Definition at line 967 of file TrackingVolume.cxx.

{
  if (m_confinedLayers) {
    std::span<Trk::Layer* const> layers = m_confinedLayers->arrayObjects();
    // forward loop
    const Trk::Layer* lastLayer = nullptr;
    std::span<Trk::Layer* const>::iterator layerIter = layers.begin();
    for (; layerIter != layers.end(); ++layerIter) {
      if (*layerIter) {
        // register the layers
        (**layerIter).setBinUtility(confinedLayers()->binUtility()
                                    ? confinedLayers()->binUtility()
                                    : nullptr);
        (**layerIter).setPreviousLayer(lastLayer);
        // register the volume
        (**layerIter).encloseTrackingVolume(*this);
      }
      lastLayer = (*layerIter);
    }
    // backward loop
    lastLayer = nullptr;
    layerIter = layers.end();
    --layerIter;
    for (;; --layerIter) {
      if (*layerIter) {
        (**layerIter).setNextLayer(lastLayer);
      }
      lastLayer = (*layerIter);
      if (layerIter == layers.begin()) {
        break;
      }
    }
  }
}

isAlignable()

bool Trk::AlignableTrackingVolume::isAlignable ( ) const

inlinefinaloverridevirtual

Reimplemented from Trk::TrackingVolume.

Definition at line 72 of file AlignableTrackingVolume.h.

                                                       {
  return true;
}

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

{
 
  this->moveVolume(transform);
 
  // confined 'ordered' layers
  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
  if (confLayers)
    for (Trk::Layer* clayIter : confLayers->arrayObjects()){
      clayIter->moveLayer(transform);
    }
 
  // confined 'unordered' layers
  Trk::ArraySpan<Trk::Layer* const> confArbLayers =
    confinedArbitraryLayers();
  if (!confArbLayers.empty()){
    for (Trk::Layer* calayIter : confArbLayers){
      calayIter->moveLayer(transform);
    }
  }
 
  // confined volumes
  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
  if (confVolumes){
    // retrieve array objects and apply the transform
    for (Trk::TrackingVolume* cVolumesIter : confVolumes->arrayObjects()){
      (cVolumesIter)->moveTV(transform);
    }
  }
 
  // confined unordered volumes
  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes = confinedDenseVolumes();
  if (!confDenseVolumes.empty())
    // retrieve array objects and apply the transform
    for (Trk::TrackingVolume* cVolumesIter : confDenseVolumes){
      cVolumesIter->moveTV(transform);
    }
}

moveVolume()

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

inherited

move Volume

Definition at line 1034 of file TrackingVolume.cxx.

{
  if (m_transform) {
    Amg::Transform3D transf = shift * (*m_transform);
    this->m_transform = std::make_unique<Amg::Transform3D>(transf);
  } else {
    this->m_transform = std::make_unique<Amg::Transform3D>(shift);
  }
  this->m_center = (m_transform->translation());
}

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

{
  const Trk::Layer* nextLayer = nullptr;
  if (m_confinedLayers){
    nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
  }
  // forward it in this case
  if (!skipNavLayer){
    return nextLayer;
  }
  // if only material or layers
  if (nextLayer &&
      (nextLayer->layerMaterialProperties() || nextLayer->surfaceArray())){
    return nextLayer;
  }
  // try to get the next layer that has either material or sub surfaces
  while (nextLayer && (!(nextLayer->layerMaterialProperties()) &&
                       !(nextLayer->surfaceArray()))){
    nextLayer = (confinedLayers()->nextObject(gp, mom, associatedResult));
  }
  return nextLayer;
}

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

{
  if (m_confinedVolumes){
    return (m_confinedVolumes->nextObject(gp, mom));
  }
  return this;
}

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

{
  // get the boundary surfaces & intersect them
  const Trk::TrackingVolume* nVolume = nullptr;
  // fix the direction once
  bool forceDir = (pDir == Trk::alongMomentum || pDir == Trk::oppositeMomentum);
  double dirScalor = (pDir == Trk::oppositeMomentum) ? -1. : 1.;
  Amg::Vector3D cDir = dirScalor * dir;
  double pathLength = 10e10;
  // now loop through the and find the closest
  const auto& bSurfaces = boundarySurfaces();
  for (size_t ib = 0; ib < bSurfaces.size(); ++ib) {
    // get the intersection soltuion
    Trk::Intersection sfI =
      bSurfaces[ib]->surfaceRepresentation().straightLineIntersection(
        gp, cDir, forceDir, true);
    if (sfI.valid &&
        (sfI.pathLength * sfI.pathLength) < (pathLength * pathLength)) {
      // assign the next Volume
      Trk::PropDirection attachedDir =
        sfI.pathLength > 0. ? Trk::alongMomentum : Trk::oppositeMomentum;
      pathLength = sfI.pathLength;
      nVolume = bSurfaces[ib]->attachedVolume(gp, cDir, attachedDir);
    }
  }
  return nVolume;
}

onVolumeBoundary()

template<class T>

bool Trk::TrackingVolume::onVolumeBoundary ( const T & pars ) const

inherited

show if you are on a boundary surface

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

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

scale()

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

inlineinherited

scaling method

Definition at line 240 of file Material.h.

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

screenDump()

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

inherited

Definition at line 1185 of file TrackingVolume.cxx.

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

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

{
  // never overwrite what is already signed, that's a crime
  if (m_geometrySignature == Trk::Unsigned) {
    m_geometrySignature = geosign;
  }
  m_geometryType = geotype;
 
  // confined volumes
  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
  if (confVolumes) {
    std::span<Trk::TrackingVolume* const> volumes =
      confVolumes->arrayObjects();
    for (const auto& volumesIter : volumes){
      if (volumesIter){
        volumesIter->sign(geosign, geotype);
      }
    }
  }
  // same procedure for the detached volumes
  Trk::ArraySpan<Trk::DetachedTrackingVolume* const> confDetachedVolumes =
    confinedDetachedVolumes();
  if (!confDetachedVolumes.empty()) {
    for (const auto& volumesIter : confDetachedVolumes) {
      if (volumesIter) {
        volumesIter->sign(geosign, geotype);
      }
    }
  }
  // confined dense volumes
  Trk::ArraySpan<Trk::TrackingVolume* const> confDenseVolumes =
    confinedDenseVolumes();
  if (!confDenseVolumes.empty()) {
    for (const auto& volumesIter : confDenseVolumes) {
      if (volumesIter) {
        volumesIter->sign(geosign, geotype);
      }
    }
  }
}

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

{
  // case a : Layers exist
  Trk::BinnedArray<Trk::Layer>* confLayers = confinedLayers();
  if (confLayers) {
    for (Trk::Layer* clay : confLayers->arrayObjects())
      if (clay) {
        if (clay->surfaceRepresentation().type() ==
              Trk::SurfaceType::Cylinder &&
            !(center().isApprox(clay->surfaceRepresentation().center()))) {
          clay->resizeAndRepositionLayer(volumeBounds(), center(), envelope);
        } else {
          clay->resizeLayer(volumeBounds(), envelope);
        }
      } else
        msgstream << MSG::WARNING
                  << "  ---> found 0 pointer to layer in Volume [ "
                  << volumeName() << " ], indicates problem." << endmsg;
  }
  // case b : container volume -> step down
  Trk::BinnedArray<Trk::TrackingVolume>* confVolumes = confinedVolumes();
  if (confVolumes) {
    for (const auto& cVolumesIter : confVolumes->arrayObjects())
      cVolumesIter->synchronizeLayers(msgstream, envelope);
  }
}

toString()

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

inlineinherited

spit out as a string

Definition at line 231 of file Material.h.

                             {
    std::ostringstream sout;
    sout << std::setiosflags(std::ios::fixed) << std::setprecision(4);
    sout << "(" << X0 << " | " << L0 << " | " << A << " | " << Z << " | " << rho
         << ")";
    return sout.str();
  }

transform()

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

inlineinherited

Return methods for geometry transform.

Definition at line 83 of file Volume.h.

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

volumeBounds() [1/2]

VolumeBounds & Trk::Volume::volumeBounds ( )

inlineinherited

Definition at line 102 of file Volume.h.

    {
      return *(m_volumeBounds.get());
    }

volumeBounds() [2/2]

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

inlineinherited

returns the volumeBounds()

Definition at line 96 of file Volume.h.

    {
      return *(m_volumeBounds.get());
    }

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.

{ return (*this).X0; }

zOverAtimesRho()

float Trk::Material::zOverAtimesRho ( ) const

inlineinherited

access to members

Definition at line 226 of file Material.h.

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

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

private

Definition at line 59 of file AlignableTrackingVolume.h.

m_binnedMaterial

const BinnedMaterial Trk::AlignableTrackingVolume::m_binnedMaterial {}

private

Definition at line 60 of file AlignableTrackingVolume.h.

{};

m_boundarySurfaces

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

privateinherited

Definition at line 438 of file TrackingVolume.h.

{nullptr};

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}

privateinherited

Color code for displaying.

Definition at line 458 of file TrackingVolume.h.

{20} ; 

m_confinedArbitraryLayers

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

privateinherited

Definition at line 448 of file TrackingVolume.h.

{nullptr};

m_confinedDenseVolumes

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

privateinherited

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

Definition at line 446 of file TrackingVolume.h.

{nullptr};

m_confinedDetachedVolumes

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

privateinherited

Additionally, Unordered subvolumes (we own the elements)

Definition at line 444 of file TrackingVolume.h.

{nullptr};

m_confinedLayers

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

privateinherited

Array of Volumes inside the Volume.

Definition at line 440 of file TrackingVolume.h.

{nullptr};

m_confinedVolumes

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

privateinherited

Detached subvolumes.

Note that we do not own the volumes/elements

Definition at line 442 of file TrackingVolume.h.

{nullptr};

m_geometrySignature

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

privateinherited

Definition at line 456 of file TrackingVolume.h.

{Trk::Unsigned};

m_geometryType

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

privateinherited

The Signature done by the GeometryBuilder.

Definition at line 454 of file TrackingVolume.h.

{Trk::NumberOfGeometryTypes};

m_layerAttemptsCalculator

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

privateinherited

defines how the Extrapolator propagates through this

Definition at line 452 of file TrackingVolume.h.

{nullptr};

m_motherVolume

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

privateinherited

boundary Surfaces, they can be shared between volumes

Definition at line 436 of file TrackingVolume.h.

{nullptr};

m_name

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

privateinherited

Volume name for debug reasons.

Definition at line 457 of file TrackingVolume.h.

{"undefined"};       

m_outsideGlueVolumes

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

privateinherited

provided the number of layer attempts

Definition at line 450 of file TrackingVolume.h.

{nullptr};

m_sampleID

int Trk::AlignableTrackingVolume::m_sampleID {}

private

Definition at line 61 of file AlignableTrackingVolume.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:

• AlignableTrackingVolume.h
• AlignableTrackingVolume.cxx