Trk::TrackingVolume Class Reference

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

#include <TrackingVolume.h>

Inheritance diagram for Trk::TrackingVolume:

Public Member Functions
	TrackingVolume ()=default
	Default Constructor.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume.
	TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< LayerArray > subLayers=nullptr, std::unique_ptr< TrackingVolumeArray > subVolumes=nullptr, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< std::vector< DetachedTrackingVolume * > > detachedSubVolumes, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with detached subvolumes.
	TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< std::vector< DetachedTrackingVolume * > > detachedSubVolumes, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with detached subvolumes.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< const std::vector< TrackingVolume * > > unorderedSubVolumes, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with unordered subvolumes.
	TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< const std::vector< TrackingVolume * > > unorderedSubVolumes, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with unordered subvolumes.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, const Material &matprop, std::unique_ptr< const std::vector< Layer * > > arbitraryLayers, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with arbitrary layers.
	TrackingVolume (const Volume &volume, const Material &matprop, std::unique_ptr< const std::vector< Layer * > > arbitraryLayers, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with arbitrary layers.
	TrackingVolume (std::unique_ptr< Amg::Transform3D > htrans, std::shared_ptr< VolumeBounds > volbounds, std::unique_ptr< const std::vector< Layer * > > arbitraryLayers, std::unique_ptr< const std::vector< TrackingVolume * > > unorderedSubVolumes, const Material &matprop, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -.
	TrackingVolume (const Volume &volume, std::unique_ptr< const std::vector< Layer * > > arbitraryLayers, std::unique_ptr< const std::vector< TrackingVolume * > > unorderedSubVolumes, const Material &matprop, const std::string &volumeName="undefined")
	Constructor for a full equipped Tracking Volume with arbitrary layers AND subVolumes -.
	TrackingVolume (const TrackingVolume &trVol, Amg::Transform3D &transform)
	copy constructor with shift
virtual	~TrackingVolume () override
	Destructor.
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
virtual bool	isAlignable () const
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
	TrackingVolume (const TrackingVolume &)=delete
	Forbidden copy constructor.
TrackingVolume &	operator= (const TrackingVolume &)=delete
	Forbid assignment.

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

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

Detailed Description

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

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

navigation with in 5 different ways:

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

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

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

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

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Christos Anastopoulos (Athena MT modifications)

Definition at line 116 of file TrackingVolume.h.

Constructor & Destructor Documentation

TrackingVolume() [1/14]

Trk::TrackingVolume::TrackingVolume ( )

default

Default Constructor.

TrackingVolume() [2/14]

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

Constructor for a full equipped Tracking Volume.

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

Definition at line 50 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material()
  , m_boundarySurfaces{}
  , m_confinedLayers(std::move(subLayers))
  , m_confinedVolumes(std::move(subVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
  createLayerAttemptsCalculator();
  interlinkLayers();
}

TrackingVolume() [3/14]

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

Constructor for a full equipped Tracking Volume.

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

Definition at line 69 of file TrackingVolume.cxx.

  : Volume(volume)
  , Material(matprop)
  , m_confinedLayers(std::move(subLayers))
  , m_confinedVolumes(std::move(subVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
  createLayerAttemptsCalculator();
  interlinkLayers();
}

TrackingVolume() [4/14]

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

Constructor for a full equipped Tracking Volume.

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

Definition at line 86 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material(matprop)
  , m_confinedLayers(std::move(subLayers))
  , m_confinedVolumes(std::move(subVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
  createLayerAttemptsCalculator();
  interlinkLayers();
}

TrackingVolume() [5/14]

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

Constructor for a full equipped Tracking Volume with detached subvolumes.

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

Definition at line 105 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material(matprop)
  , m_confinedDetachedVolumes(std::move(detachedSubVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [6/14]

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

Constructor for a full equipped Tracking Volume with detached subvolumes.

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

Definition at line 120 of file TrackingVolume.cxx.

  : Volume(volume)
  , Material(matprop)
  , m_confinedDetachedVolumes(std::move(detachedSubVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [7/14]

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

Constructor for a full equipped Tracking Volume with unordered subvolumes.

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

Definition at line 134 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material(matprop)
  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [8/14]

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

Constructor for a full equipped Tracking Volume with unordered subvolumes.

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

Definition at line 149 of file TrackingVolume.cxx.

  : Volume(volume)
  , Material(matprop)
  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [9/14]

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

Constructor for a full equipped Tracking Volume with arbitrary layers.

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

Definition at line 163 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material(matprop)
  , m_confinedArbitraryLayers(std::move(layers))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [10/14]

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

Constructor for a full equipped Tracking Volume with arbitrary layers.

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

Definition at line 178 of file TrackingVolume.cxx.

  : Volume(volume)
  , Material(matprop)
  , m_confinedArbitraryLayers(std::move(layers))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [11/14]

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

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

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

Definition at line 191 of file TrackingVolume.cxx.

  : Volume(std::move(htrans), std::move(volbounds))
  , Material(matprop)
  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
  , m_confinedArbitraryLayers(std::move(layers))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [12/14]

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

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

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

Definition at line 208 of file TrackingVolume.cxx.

  : Volume(volume)
  , Material(matprop)
  , m_confinedDenseVolumes(std::move(unorderedSubVolumes))
  , m_confinedArbitraryLayers(std::move(layers))
  , m_name(volumeName)
{
  createBoundarySurfaces();
}

TrackingVolume() [13/14]

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

copy constructor with shift

Definition at line 223 of file TrackingVolume.cxx.

  : Volume(trVol, transform)
  , Material(trVol)
  , m_motherVolume(trVol.m_motherVolume)
  , m_boundarySurfaces{}
  , m_name(trVol.m_name)
  , m_colorCode(trVol.m_colorCode)
{
  // createBoundarySurfaces
  m_boundarySurfaces.reserve(trVol.boundarySurfaces().size());
  const Trk::TrackingVolume* in = nullptr;
  const Trk::TrackingVolume* out = nullptr;
  for (size_t ib = 0; ib < trVol.boundarySurfaces().size(); ib++) {
    in = trVol.boundarySurfaces()[ib]->insideVolume() == &trVol ? this : nullptr;
    out = in == nullptr ? this : nullptr;
    const Trk::CylinderSurface* cyl =
        dynamic_cast<const Trk::CylinderSurface*>(trVol.boundarySurfaces()[ib]);
    const Trk::DiscSurface* dis =
        dynamic_cast<const Trk::DiscSurface*>(trVol.boundarySurfaces()[ib]);
    const Trk::PlaneSurface* pla =
        dynamic_cast<const Trk::PlaneSurface*>(trVol.boundarySurfaces()[ib]);
    const Trk::SubtractedCylinderSurface* scyl =
        dynamic_cast<const Trk::SubtractedCylinderSurface*>(
            trVol.boundarySurfaces()[ib]);
    const Trk::SubtractedPlaneSurface* spla =
        dynamic_cast<const Trk::SubtractedPlaneSurface*>(
            trVol.boundarySurfaces()[ib]);
    if (scyl) {
      m_boundarySurfaces.push_back(
        std::make_shared<Trk::BoundarySubtractedCylinderSurface<Trk::TrackingVolume>>(in, out, *scyl, transform));
    } else if (spla) {
      m_boundarySurfaces.push_back(
        std::make_shared<Trk::BoundarySubtractedPlaneSurface<Trk::TrackingVolume>>(in, out, *spla, transform));
    } else if (cyl) {
      m_boundarySurfaces.push_back(
        std::make_shared<Trk::BoundaryCylinderSurface<Trk::TrackingVolume>>(in, out, *cyl, transform));
    } else if (dis) {
      m_boundarySurfaces.push_back(
        std::make_shared<Trk::BoundaryDiscSurface<Trk::TrackingVolume>>(in, out, *dis, transform));
    } else if (pla) {
      m_boundarySurfaces.push_back(
        std::make_shared<Trk::BoundaryPlaneSurface<Trk::TrackingVolume>>(in, out, *pla, transform));
    }
  }
 
  // confined layers
  const Trk::BinnedArray<Trk::Layer>* confinedLayers = trVol.confinedLayers();
  if (confinedLayers) {
    std::span<Trk::Layer const* const> layers = confinedLayers->arrayObjects();
    std::vector<std::shared_ptr<Trk::Layer>> layerOrder;
    layerOrder.reserve(layers.size());
    for (const auto *layer : layers) {
      const Trk::PlaneLayer* lay = dynamic_cast<const Trk::PlaneLayer*>(layer);
      if (lay) {
        Trk::PlaneLayer* newlay = new Trk::PlaneLayer(*lay, transform);
        layerOrder.push_back(std::shared_ptr<Trk::Layer>(newlay));
      }
    }
    const Trk::NavBinnedArray1D<Trk::Layer>* confLays =
        dynamic_cast<const Trk::NavBinnedArray1D<Trk::Layer>*>(confinedLayers);
    if (confLays) {
      m_confinedLayers = std::make_unique<Trk::NavBinnedArray1D<Trk::Layer>>(
        *confLays,
        std::vector<std::shared_ptr<Trk::Layer>>(layerOrder),
        transform);
    }
  }
 
  // confined 'unordered' layers
  Trk::ArraySpan<const Trk::Layer* const> confinedArbitraryLayers =
    trVol.confinedArbitraryLayers();
  if (!confinedArbitraryLayers.empty()) {
    // clone & apply the transform
    std::vector<Trk::Layer*> uLayers;
    uLayers.reserve(confinedArbitraryLayers.size());
    for (const auto *confinedArbitraryLayer : confinedArbitraryLayers) {
      const Trk::SubtractedPlaneLayer* slayer =
          dynamic_cast<const Trk::SubtractedPlaneLayer*>(
              confinedArbitraryLayer);
      const Trk::SubtractedCylinderLayer* sclayer =
          dynamic_cast<const Trk::SubtractedCylinderLayer*>(
              confinedArbitraryLayer);
      const Trk::PlaneLayer* layer =
          dynamic_cast<const Trk::PlaneLayer*>(confinedArbitraryLayer);
      const Trk::CylinderLayer* clayer =
          dynamic_cast<const Trk::CylinderLayer*>(confinedArbitraryLayer);
 
      if (slayer) {
        Trk::SubtractedPlaneLayer* lay = new Trk::SubtractedPlaneLayer(*slayer, transform);
        uLayers.push_back(lay);
      } else if (layer) {
        Trk::PlaneLayer* lay = new Trk::PlaneLayer(*layer, transform);
        uLayers.push_back(lay);
      } else if (sclayer) {
        Trk::SubtractedCylinderLayer* lay = new Trk::SubtractedCylinderLayer(*sclayer, transform);
        uLayers.push_back(lay);
      } else if (clayer) {
        Trk::CylinderLayer* lay = new Trk::CylinderLayer(*clayer, transform);
        uLayers.push_back(lay);
      }
    }
    m_confinedArbitraryLayers = std::make_unique<std::vector<Trk::Layer*>>(uLayers);
  }
 
  // confined volumes
  const Trk::BinnedArray<Trk::TrackingVolume>* confinedVolumes =
    trVol.confinedVolumes();
  if (confinedVolumes) {
    // retrieve array objects and apply the transform
    std::span<Trk::TrackingVolume const * const > volumes =
      confinedVolumes->arrayObjects();
    std::vector<std::shared_ptr<Trk::TrackingVolume>> volOrder;
    volOrder.reserve(volumes.size());
    for (const auto *volume : volumes) {
      Trk::TrackingVolume* vol = new Trk::TrackingVolume(*volume, transform);
      volOrder.push_back(std::shared_ptr<TrackingVolume>(vol));
    }
    const Trk::NavBinnedArray1D<Trk::TrackingVolume>* confVols =
        dynamic_cast<const Trk::NavBinnedArray1D<Trk::TrackingVolume>*>(
            confinedVolumes);
    if (confVols)
      m_confinedVolumes = std::make_unique<Trk::NavBinnedArray1D<Trk::TrackingVolume>>(
        *confVols,
        std::vector<std::shared_ptr<Trk::TrackingVolume>>(volOrder),
        transform);
  }
 
  // confined unordered volumes
  Trk::ArraySpan<const Trk::TrackingVolume* const> confinedDenseVolumes =
    trVol.confinedDenseVolumes();
  if (!confinedDenseVolumes.empty()) {
    std::vector<Trk::TrackingVolume*> newVol;
    newVol.reserve(confinedDenseVolumes.size());
    // retrieve array objects and apply the transform
    for (const auto *confinedDenseVolume : confinedDenseVolumes) {
      Trk::TrackingVolume* vol = new Trk::TrackingVolume(*confinedDenseVolume, transform);
      newVol.push_back(vol);
    }
    m_confinedDenseVolumes = std::make_unique<const std::vector<Trk::TrackingVolume*>>(newVol);
  }
}

~TrackingVolume()

Trk::TrackingVolume::~TrackingVolume ( )

overridevirtual

Destructor.

Definition at line 366 of file TrackingVolume.cxx.

{
  //We need to clean the elements we own from the vectors
  if (m_confinedDenseVolumes) {
    for (auto * confinedDenseVolume : *m_confinedDenseVolumes){
      delete confinedDenseVolume;
    }
  }
  if (m_confinedArbitraryLayers) {
    for (auto * confinedArbitraryLayer : *m_confinedArbitraryLayers){
      delete confinedArbitraryLayer;
    }
  }
}

TrackingVolume() [14/14]

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

privatedelete

Forbidden copy constructor.

Member Function Documentation

addMaterial()

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

add Material

Definition at line 736 of file TrackingVolume.cxx.

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

assocDetachedSubVolumes()

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

Return the associated detached subvolumes.

Definition at line 624 of file TrackingVolume.cxx.

{
  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

)

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

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

)

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

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

boundarySurface()

const Trk::BoundarySurface< Trk::TrackingVolume > * Trk::TrackingVolume::boundarySurface

(

const ObjectAccessor::value_type &

oa

)

const

Get the BoundarySurface to the appointed Accessor state.

Definition at line 822 of file TrackingVolume.cxx.

{
  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

(

)

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

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

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

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 )

staticprivate

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

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

Get the color code.

compactify()

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

private

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

Definition at line 1131 of file TrackingVolume.cxx.

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

(

)

Return the confined subLayer array.

Layers are not const

confinedArbitraryLayers() [2/2]

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

(

)

const

Return the confined subLayer array.

confinedDenseVolumes() [1/2]

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

(

)

confinedDenseVolumes() [2/2]

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

(

)

const

Return unordered subVolumes - not the ownership.

confinedDetachedVolumes() [1/2]

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

(

)

confinedDetachedVolumes() [2/2]

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

(

)

const

Return detached subVolumes - not the ownership.

confinedLayers() [1/2]

LayerArray * Trk::TrackingVolume::confinedLayers

(

)

Return the subLayer array.

confinedLayers() [2/2]

const LayerArray * Trk::TrackingVolume::confinedLayers

(

)

const

Return the subLayer array.

confinedVolumes() [1/2]

TrackingVolumeArray * Trk::TrackingVolume::confinedVolumes

(

)

Return the subLayer array.

confinedVolumes() [2/2]

const TrackingVolumeArray * Trk::TrackingVolume::confinedVolumes

(

)

const

Return the subLayer array.

createBoundarySurfaces()

void Trk::TrackingVolume::createBoundarySurfaces ( )

private

Create Boundary Surface.

Definition at line 828 of file TrackingVolume.cxx.

{
  // 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 ( )

private

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

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

exitLayer()

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

Return the exit Layer from a TrackingVolume.

geometrySignature()

GeometrySignature Trk::TrackingVolume::geometrySignature

(

)

const

return the Signature

geometryType()

GeometryType Trk::TrackingVolume::geometryType

(

)

const

return the Signature

getMotherVolume()

const TrackingVolume * Trk::TrackingVolume::getMotherVolume

(

)

const

Return the MotherVolume - if it exists.

glueVolumesDescriptor() [1/2]

Trk::GlueVolumesDescriptor & Trk::TrackingVolume::glueVolumesDescriptor

(

)

Definition at line 1016 of file TrackingVolume.cxx.

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

glueVolumesDescriptor() [2/2]

const Trk::GlueVolumesDescriptor & Trk::TrackingVolume::glueVolumesDescriptor

(

)

const

Definition at line 1025 of file TrackingVolume.cxx.

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

indexContainedMaterialLayers()

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

private

reIndex the material layers of the TrackingVolume

Definition at line 689 of file TrackingVolume.cxx.

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

private

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

private

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

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

virtual

Reimplemented in Trk::AlignableTrackingVolume.

layerAttempts()

unsigned int Trk::TrackingVolume::layerAttempts

(

BoundarySurfaceFace

exitFace

)

const

Layer attempts - as provided by the LayerAttemptCreator.

materialLayersOrdered()

template<class T>

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

Return the material layers ordered based on straight line intersections:

• startLayer and endLayer are included in the list

maxLayerAttempts()

unsigned int Trk::TrackingVolume::maxLayerAttempts

(

)

const

Layer attempts - as provided by the LayerAttemptCreator.

moveTV()

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

private

move the Tracking Volume

Definition at line 1063 of file TrackingVolume.cxx.

{
 
  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

)

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

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

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

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

show if you are on a boundary surface

operator=()

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

privatedelete

Forbid assignment.

mother volume of this volume view ptr

registerColorCode()

void Trk::TrackingVolume::registerColorCode

(

unsigned int

icolor

)

Register the color code.

registerOutsideGlueVolumes()

void Trk::TrackingVolume::registerOutsideGlueVolumes

(

Trk::GlueVolumesDescriptor *

gvd

)

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

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

Definition at line 1010 of file TrackingVolume.cxx.

{
  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

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

)

set the MotherVolume

sign()

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

sign the volume - the geometry builder has to do that

Definition at line 766 of file TrackingVolume.cxx.

{
  // 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. )

private

method to synchronize the layers with potentially updated volume bounds:

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

Definition at line 1103 of file TrackingVolume.cxx.

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

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

Friends And Related Symbol Documentation

DetachedTrackingVolume

friend class DetachedTrackingVolume

friend

Give the DetachedTrackingVolume friend rights.

Definition at line 128 of file TrackingVolume.h.

TrackingGeometry

friend class TrackingGeometry

friend

Give the TrackingGeometry friend rights.

Definition at line 125 of file TrackingVolume.h.

TrackingVolumeManipulator

friend class TrackingVolumeManipulator

friend

The TrackingVolumeManipulator has to be a friend.

Definition at line 122 of file TrackingVolume.h.

Member Data Documentation

A

float Trk::Material::A

inherited

Definition at line 122 of file Material.h.

composition

MaterialComposition* Trk::Material::composition

inherited

Definition at line 127 of file Material.h.

dEdX

float Trk::Material::dEdX

inherited

Definition at line 125 of file Material.h.

L0

float Trk::Material::L0

inherited

Definition at line 121 of file Material.h.

m_boundarySurfaces

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

private

Definition at line 438 of file TrackingVolume.h.

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

private

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}

private

Definition at line 448 of file TrackingVolume.h.

{nullptr};

m_confinedDenseVolumes

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

private

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

Definition at line 446 of file TrackingVolume.h.

{nullptr};

m_confinedDetachedVolumes

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

private

Additionally, Unordered subvolumes (we own the elements)

Definition at line 444 of file TrackingVolume.h.

{nullptr};

m_confinedLayers

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

private

Array of Volumes inside the Volume.

Definition at line 440 of file TrackingVolume.h.

{nullptr};

m_confinedVolumes

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

private

Detached subvolumes.

Note that we do not own the volumes/elements

Definition at line 442 of file TrackingVolume.h.

{nullptr};

m_geometrySignature

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

private

Definition at line 456 of file TrackingVolume.h.

{Trk::Unsigned};

m_geometryType

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

private

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}

private

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}

private

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

private

Volume name for debug reasons.

Definition at line 457 of file TrackingVolume.h.

{"undefined"};       

m_outsideGlueVolumes

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

private

provided the number of layer attempts

Definition at line 450 of file TrackingVolume.h.

{nullptr};

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:

• TrackingVolume.h
• TrackingVolume.cxx