GXF::Layer Class Reference

Base Class for a Detector Layer in the Tracking realm. More...

#include <Layer.h>

Inheritance diagram for GXF::Layer:

Collaboration diagram for GXF::Layer:

Public Member Functions
	Layer ()=default
	Default Constructor.
	Layer (const LayerMaterialProperties &laymatprop, double thickness=0., std::unique_ptr< OverlapDescriptor > od=nullptr, int ltype=int(passive))
	Constructor with MaterialProperties.
	Layer (std::unique_ptr< SurfaceArray > surfaceArray, double thickness=0., std::unique_ptr< OverlapDescriptor >=nullptr, int ltype=int(passive))
	Constructor with pointer to SurfaceArray (passing ownership)
	Layer (std::unique_ptr< SurfaceArray > surfaceArray, const LayerMaterialProperties &laymatprop, double thickness=0., std::unique_ptr< OverlapDescriptor > od=nullptr, int ltype=int(passive))
	Constructor with MaterialProperties and pointer SurfaceArray (passing ownership)
virtual	~Layer ()=default
	Destructor.
const SurfaceArray *	surfaceArray () const
	Return the entire SurfaceArray, returns nullptr if no SurfaceArray.
SurfaceArray *	surfaceArray ()
	Return the entire SurfaceArray, returns nullptr if no SurfaceArray.
const Surface *	subSurface (const Amg::Vector3D &gp) const
	If no subSurface array is defined or no subSurface can be found to the given Amg::Vector3D, it would return 0.
const Surface *	subSurface (const Amg::Vector2D &lp) const
	If no subSurface array is defined or no subSurface can be found to the given Amg::Vector2D, it would return 0.
const Surface *	subSurfaceReference (unsigned int idx=0) const
	Return a reference sub surface of the layer, usually the first one in the array.
virtual const Surface &	surfaceRepresentation () const=0
	Transforms the layer into a Surface representation for extrapolation.
virtual Surface &	surfaceRepresentation ()=0
double	thickness () const
	Return the Thickness of the Layer.
template<class T>
bool	onLayer (const T &parameters, const BoundaryCheck &bcheck=BoundaryCheck(true)) const
	templated on Layer method
virtual bool	isOnLayer (const Amg::Vector3D &gp, const BoundaryCheck &bcheck=BoundaryCheck(true)) const
	isOnLayer() method, using isOnSurface() with Layer specific tolerance
const LayerMaterialProperties *	layerMaterialProperties () const
	getting the LayerMaterialProperties including full/pre/post update
const MaterialProperties *	fullUpdateMaterialProperties (const TrackParameters &par) const
	getting the MaterialProperties back - for full update
virtual double	preUpdateMaterialFactor (const TrackParameters &, PropDirection) const
	getting the MaterialProperties back - for pre-update
virtual double	postUpdateMaterialFactor (const TrackParameters &, PropDirection) const
	getting the MaterialProperties back - for pre-update
const OverlapDescriptor *	overlapDescriptor () const
	gettint hte overlap descriptor
const Layer *	previousLayer (bool skipNavLayer=false) const
	getting what's stored to be the previous Layer, boolean to skip navigation layers
void	setPreviousLayer (const Layer *)
	set the previous Layer
const Layer *	nextLayer (const Amg::Vector3D &gp, const Amg::Vector3D &udir) const
	getting the next/previous Layer if registered - unit for direction vector required
const Layer *	nextLayer (bool skipNavLayer=false) const
	getting what's stored to be the next Layer, boolean to skip navigation layers
void	setNextLayer (const Layer *)
	set the next Layer
const BinUtility *	binUtility () const
	access the BinUtility
void	setBinUtility (const BinUtility *)
	set the BinUtility
virtual const Surface &	surfaceOnApproach (const Amg::Vector3D &pos, const Amg::Vector3D &dir, PropDirection pdir, const BoundaryCheck &bcheck, bool resolveSubSurfaces=0, const ICompatibilityEstimator *ice=nullptr) const
	Surface seen on approach - if not defined differently, it is the surfaceRepresentation()
size_t	compatibleSurfaces (std::vector< SurfaceIntersection > &cSurfaces, const TrackParameters &pars, PropDirection pdir, const BoundaryCheck &bcheck, bool materialSurfacesOnly=true, const Surface *startSurface=nullptr, const Surface *endSurface=nullptr, const ICompatibilityEstimator *ice=nullptr) const
	get compatible surfaces starting from charged parameters
size_t	compatibleSurfaces (std::vector< SurfaceIntersection > &cSurfaces, const NeutralParameters &pars, PropDirection pdir, const BoundaryCheck &bcheck, bool materialSurfacesOnly=true, const Surface *startSurface=nullptr, const Surface *endSurface=nullptr, const ICompatibilityEstimator *ice=nullptr) const
	get compatible surfaces starting from neutral parameters
virtual bool	hasSubStructure (bool resolveSensitive=false) const
	Has sub-structure method:
const TrackingVolume *	enclosingTrackingVolume () const
	get the confining TrackingVolume
const DetachedTrackingVolume *	enclosingDetachedTrackingVolume () const
	get the confining DetachedTrackingVolume
const LayerIndex &	layerIndex () const
	get the layerIndex
int	layerType () const
	get the Layer coding
void	setLayerType (int identifier)
	set the Layer coding
void	assignMaterialProperties (const LayerMaterialProperties &, double scale=1.0)
	assignMaterialPropeties
virtual void	moveLayer (Amg::Transform3D &)=0
	move the Layer
void	registerRepresentingVolume (const Volume *theVol)
	register Volume associated to the layer
const Volume *	representingVolume () const
	get the Volume associated to the layer
void	setRef (double)
	set the reference measure
double	getRef () const
	get the reference measure
void	encloseTrackingVolume (const TrackingVolume &tvol)
	private method to set the enclosed detached TV
void	encloseDetachedTrackingVolume (const DetachedTrackingVolume &tvol)
template<class T>
size_t	getCompatibleSurfaces (std::vector< SurfaceIntersection > &cSurfaces, const T &pars, PropDirection pdir, const BoundaryCheck &bcheck, bool materialSurfacesOnly=true, const Surface *startSurface=nullptr, const Surface *endSurface=nullptr, const ICompatibilityEstimator *ice=nullptr) const
	get compatible surfaces starting from charged parameters
void	compactify (size_t &cSurfaces, size_t &tSurfaces)
	register layer index for material map registration
void	registerLayerIndex (const LayerIndex &lIdx)
virtual void	resizeLayer (const VolumeBounds &, double)=0
	private method to set enclosing TrackingVolume, called by friend class only optionally, the layer can be resized to the dimensions of the TrackingVolume
virtual void	resizeAndRepositionLayer (const VolumeBounds &vBounds, const Amg::Vector3D &vCenter, double envelope=1.)=0
	resize and reposition layer : dedicated for entry layers

Protected Member Functions
	Layer (const Layer &lay)
	Copy Constructor for Derived classes.
Layer &	operator= (const Layer &lay)
	Assignment operator for Derived classes.

Protected Attributes
std::unique_ptr< SurfaceArray >	m_surfaceArray {}
	MaterialPoperties of this layer Surface.
std::unique_ptr< LayerMaterialProperties >	m_layerMaterialProperties {}
	thickness of the Layer
double	m_layerThickness {}
	descriptor for overlap/next surface (owning ptr)
std::unique_ptr< OverlapDescriptor >	m_overlapDescriptor {}
const Layer *	m_previousLayer = nullptr
	< the previous Layer according to BinGenUtils
const Layer *	m_nextLayer = nullptr
	BinUtility for next/previous decision.
const BinUtility *	m_binUtility = nullptr
	Enclosing TrackingVolume.
const TrackingVolume *	m_enclosingTrackingVolume = nullptr
	Enclosing DetachedTrackingVolume.
const DetachedTrackingVolume *	m_enclosingDetachedTrackingVolume = nullptr
LayerIndex	m_index {-1}
	LayerIndex.
int	m_layerType {Trk::active}
	active passive layer
double	m_ref {}
	reference measure for local coordinate convertors

Detailed Description

Base Class for a Detector Layer in the Tracking realm.

An actual implemented Detector Layer inheriting from this base class has to inherit from a specific type of Surface as well. In addition, a Layer can carry:

• a SurfaceArray of Surfaces holding the actual detector elements or subSurfaces.
• LayerMaterialProperties for Surface-based materialUpdates
• an OverlapDescriptor (mainly used for blind extrapolation)
• a pointer to the TrackingVolume (can only be set by such)
• an active/passive code : 0 - activ 1 - passive [....] - other

Author

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

Christos Anastopoulos (Athena MT)

Definition at line 72 of file Layer.h.

Constructor & Destructor Documentation

Layer() [1/5]

Trk::Layer::Layer ( )

default

Default Constructor.

Layer() [2/5]

Trk::Layer::Layer	(	const LayerMaterialProperties &	laymatprop,
		double	thickness = 0.,
		std::unique_ptr< OverlapDescriptor >	od = nullptr,
		int	ltype = int(passive) )

Constructor with MaterialProperties.

Definition at line 18 of file Layer.cxx.

    : m_surfaceArray(nullptr),
      m_layerMaterialProperties(laymatprop.clone()),
      m_layerThickness(thickness),
      m_overlapDescriptor(std::move(olap)),
      m_previousLayer(nullptr),
      m_nextLayer(nullptr),
      m_binUtility(nullptr),
      m_enclosingTrackingVolume(nullptr),
      m_enclosingDetachedTrackingVolume(nullptr),
      m_index(-1),
      m_layerType(laytyp),
      m_ref(0.) {}

Layer() [3/5]

Trk::Layer::Layer	(	std::unique_ptr< SurfaceArray >	surfaceArray,
		double	thickness = 0.,
		std::unique_ptr< OverlapDescriptor >	olap = nullptr,
		int	ltype = int(passive) )

Constructor with pointer to SurfaceArray (passing ownership)

Definition at line 34 of file Layer.cxx.

    : m_surfaceArray(std::move(surfaceArray)),
      m_layerMaterialProperties(nullptr),
      m_layerThickness(thickness),
      m_overlapDescriptor(std::move(olap)),
      m_previousLayer(nullptr),
      m_nextLayer(nullptr),
      m_binUtility(nullptr),
      m_enclosingTrackingVolume(nullptr),
      m_enclosingDetachedTrackingVolume(nullptr),
      m_index(-1),
      m_layerType(laytyp),
      m_ref(0.) {}

Layer() [4/5]

Trk::Layer::Layer	(	std::unique_ptr< SurfaceArray >	surfaceArray,
		const LayerMaterialProperties &	laymatprop,
		double	thickness = 0.,
		std::unique_ptr< OverlapDescriptor >	od = nullptr,
		int	ltype = int(passive) )

Constructor with MaterialProperties and pointer SurfaceArray (passing ownership)

Definition at line 49 of file Layer.cxx.

    : m_surfaceArray(std::move(surfaceArray)),
      m_layerMaterialProperties(laymatprop.clone()),
      m_layerThickness(thickness),
      m_overlapDescriptor(std::move(olap)),
      m_previousLayer(nullptr),
      m_nextLayer(nullptr),
      m_binUtility(nullptr),
      m_enclosingTrackingVolume(nullptr),
      m_enclosingDetachedTrackingVolume(nullptr),
      m_index(-1),
      m_layerType(laytyp),
      m_ref(0.) {}

Layer() [5/5]

Trk::Layer::Layer ( const Layer & lay )

protected

Copy Constructor for Derived classes.

Definition at line 66 of file Layer.cxx.

    : m_surfaceArray(lay.m_surfaceArray ? lay.m_surfaceArray->clone()
                                        : nullptr),
      m_layerMaterialProperties(lay.m_layerMaterialProperties
                                    ? lay.m_layerMaterialProperties->clone()
                                    : nullptr),
      m_layerThickness(lay.m_layerThickness),
      m_overlapDescriptor(
          lay.m_overlapDescriptor ? lay.m_overlapDescriptor->clone() : nullptr),
      m_previousLayer(nullptr),
      m_nextLayer(nullptr),
      m_binUtility(nullptr),
      m_enclosingTrackingVolume(nullptr),
      m_enclosingDetachedTrackingVolume(nullptr),
      m_index(-1),
      m_layerType(lay.m_layerType),
      m_ref(lay.m_ref) {}

~Layer()

virtual Trk::Layer::~Layer ( )

virtualdefault

Destructor.

Member Function Documentation

assignMaterialProperties()

void Trk::Layer::assignMaterialProperties	(	const LayerMaterialProperties &	prop,
		double	scale = 1.0 )

assignMaterialPropeties

Definition at line 177 of file Layer.cxx.

                                                        {
  m_layerMaterialProperties.reset(prop.clone());
  if (scale != 1.0) {
    (*(m_layerMaterialProperties)) *= scale;
  }
}

binUtility()

const BinUtility * Trk::Layer::binUtility

(

)

const

access the BinUtility

compactify()

void Trk::Layer::compactify	(	size_t &	cSurfaces,
		size_t &	tSurfaces )

register layer index for material map registration

Definition at line 186 of file Layer.cxx.

{
  // set the layer surface representation
  ++tSurfaces;
  if (surfaceRepresentation().owner() == Trk::noOwn) {
    surfaceRepresentation().setOwner(Trk::TGOwn);
    ++cSurfaces;
  }
  // set the subsurface representation, usually already owned by DetElement
  if (m_surfaceArray) {
    std::span<Trk::Surface * const> surfaces = m_surfaceArray->arrayObjects();
    for (Trk::Surface * const sIter : surfaces) {
      if (sIter && (*sIter).owner() == Trk::noOwn) {
        (*sIter).setOwner(Trk::TGOwn);
        ++cSurfaces;
      }
      ++tSurfaces;
    }
  }
}

compatibleSurfaces() [1/2]

size_t Trk::Layer::compatibleSurfaces	(	std::vector< SurfaceIntersection > &	cSurfaces,
		const NeutralParameters &	pars,
		PropDirection	pdir,
		const BoundaryCheck &	bcheck,
		bool	materialSurfacesOnly = true,
		const Surface *	startSurface = nullptr,
		const Surface *	endSurface = nullptr,
		const ICompatibilityEstimator *	ice = nullptr ) const

get compatible surfaces starting from neutral parameters

compatibleSurfaces() [2/2]

size_t Trk::Layer::compatibleSurfaces	(	std::vector< SurfaceIntersection > &	cSurfaces,
		const TrackParameters &	pars,
		PropDirection	pdir,
		const BoundaryCheck &	bcheck,
		bool	materialSurfacesOnly = true,
		const Surface *	startSurface = nullptr,
		const Surface *	endSurface = nullptr,
		const ICompatibilityEstimator *	ice = nullptr ) const

get compatible surfaces starting from charged parameters

encloseDetachedTrackingVolume()

void Trk::Layer::encloseDetachedTrackingVolume

(

const DetachedTrackingVolume &

tvol

)

encloseTrackingVolume()

void Trk::Layer::encloseTrackingVolume

(

const TrackingVolume &

tvol

)

private method to set the enclosed detached TV

enclosingDetachedTrackingVolume()

const DetachedTrackingVolume * Trk::Layer::enclosingDetachedTrackingVolume

(

)

const

get the confining DetachedTrackingVolume

enclosingTrackingVolume()

const TrackingVolume * Trk::Layer::enclosingTrackingVolume

(

)

const

get the confining TrackingVolume

fullUpdateMaterialProperties()

const Trk::MaterialProperties * Trk::Layer::fullUpdateMaterialProperties

(

const TrackParameters &

par

)

const

getting the MaterialProperties back - for full update

Definition at line 169 of file Layer.cxx.

                                          {
  if (m_layerMaterialProperties){
    return m_layerMaterialProperties->fullMaterial(parm.position());
  }
  return nullptr;
}

getCompatibleSurfaces()

template<class T>

size_t Trk::Layer::getCompatibleSurfaces	(	std::vector< SurfaceIntersection > &	cSurfaces,
		const T &	pars,
		PropDirection	pdir,
		const BoundaryCheck &	bcheck,
		bool	materialSurfacesOnly = true,
		const Surface *	startSurface = nullptr,
		const Surface *	endSurface = nullptr,
		const ICompatibilityEstimator *	ice = nullptr ) const

get compatible surfaces starting from charged parameters

propagate TrackingGeometry owner downstream

getRef()

double Trk::Layer::getRef

(

)

const

get the reference measure

hasSubStructure()

bool Trk::Layer::hasSubStructure ( bool resolveSensitive = false ) const

virtual

Has sub-structure method:

• sub-structure depending on : (a) only when required to resolve sub surfaces for sensitive hits (b) also material is ordered with sub structure

Definition at line 238 of file Layer.cxx.

                                                          {
  return resolveSensitive && m_surfaceArray;
}

isOnLayer()

bool Trk::Layer::isOnLayer ( const Amg::Vector3D & gp, const BoundaryCheck & bcheck = BoundaryCheck(true) ) const

virtual

isOnLayer() method, using isOnSurface() with Layer specific tolerance

Definition at line 135 of file Layer.cxx.

                                                            {
  return (surfaceRepresentation())
      .isOnSurface(gp, bchk, 0.5 * m_layerThickness);
}

layerIndex()

const LayerIndex & Trk::Layer::layerIndex

(

)

const

get the layerIndex

layerMaterialProperties()

const LayerMaterialProperties * Trk::Layer::layerMaterialProperties

(

)

const

getting the LayerMaterialProperties including full/pre/post update

layerType()

int Trk::Layer::layerType

(

)

const

get the Layer coding

moveLayer()

virtual void Trk::Layer::moveLayer ( Amg::Transform3D & )

pure virtual

move the Layer

nextLayer() [1/2]

const Trk::Layer * Trk::Layer::nextLayer

(

bool

skipNavLayer = false

)

const

getting what's stored to be the next Layer, boolean to skip navigation layers

Definition at line 151 of file Layer.cxx.

                                                           {
  if (!skipNavLayer) return m_nextLayer;
  const Trk::Layer* nextMatLayer = m_nextLayer;
  // get the next Material layer
  while (nextMatLayer && !nextMatLayer->layerMaterialProperties() &&
         !nextMatLayer->surfaceArray())
    nextMatLayer = nextMatLayer->nextLayer();
  return nextMatLayer;
}

nextLayer() [2/2]

const Trk::Layer * Trk::Layer::nextLayer	(	const Amg::Vector3D &	gp,
		const Amg::Vector3D &	udir ) const

getting the next/previous Layer if registered - unit for direction vector required

Definition at line 161 of file Layer.cxx.

                                                                      {
  // no binutility -> no chance to find out the direction
  if (!m_binUtility) return nullptr;
  return (m_binUtility->orderDirection(gp, mom) == Trk::next) ? m_nextLayer
                                                              : m_previousLayer;
}

onLayer()

template<class T>

bool Trk::Layer::onLayer	(	const T &	parameters,
		const BoundaryCheck &	bcheck = BoundaryCheck(true) ) const

templated on Layer method

operator=()

Trk::Layer & Trk::Layer::operator= ( const Layer & lay )

protected

Assignment operator for Derived classes.

SurfaceArray on this layer Surface (owning ptr)

Definition at line 84 of file Layer.cxx.

                                                 {
  if (this != &lay) {
    m_layerThickness = lay.m_layerThickness;
    m_enclosingDetachedTrackingVolume = lay.m_enclosingDetachedTrackingVolume;
    m_overlapDescriptor.reset(
        (lay.m_overlapDescriptor) ? lay.m_overlapDescriptor->clone() : nullptr);
    m_surfaceArray.reset((lay.m_surfaceArray) ? lay.m_surfaceArray->clone()
                                              : nullptr);
    m_layerMaterialProperties.reset(lay.m_layerMaterialProperties->clone());
 
    // just assign by pointer
    m_nextLayer = lay.m_nextLayer;
    m_previousLayer = lay.m_previousLayer;
    m_binUtility = lay.m_binUtility;
    m_enclosingTrackingVolume = lay.m_enclosingTrackingVolume;
    //
    m_index = lay.m_index;
    m_layerType = lay.m_layerType;
    m_ref = lay.m_ref;
  }
  return (*this);
}

overlapDescriptor()

const OverlapDescriptor * Trk::Layer::overlapDescriptor

(

)

const

gettint hte overlap descriptor

postUpdateMaterialFactor()

virtual double Trk::Layer::postUpdateMaterialFactor ( const TrackParameters & , PropDirection  ) const

inlinevirtual

getting the MaterialProperties back - for pre-update

Definition at line 150 of file Layer.h.

                                                               {
    return 0.;
  }

preUpdateMaterialFactor()

virtual double Trk::Layer::preUpdateMaterialFactor ( const TrackParameters & , PropDirection  ) const

inlinevirtual

getting the MaterialProperties back - for pre-update

Definition at line 144 of file Layer.h.

                                                              {
    return 1.;
  }

previousLayer()

const Trk::Layer * Trk::Layer::previousLayer

(

bool

skipNavLayer = false

)

const

getting what's stored to be the previous Layer, boolean to skip navigation layers

Definition at line 141 of file Layer.cxx.

                                                               {
  if (!skipNavLayer) return m_previousLayer;
  const Trk::Layer* prevMatLayer = m_previousLayer;
  // get the previoys Material layer
  while (prevMatLayer && !prevMatLayer->layerMaterialProperties() &&
         !prevMatLayer->surfaceArray())
    prevMatLayer = prevMatLayer->previousLayer();
  return prevMatLayer;
}

registerLayerIndex()

void Trk::Layer::registerLayerIndex

(

const LayerIndex &

lIdx

)

registerRepresentingVolume()

void Trk::Layer::registerRepresentingVolume

(

const Volume *

theVol

)

register Volume associated to the layer

representingVolume()

const Volume * Trk::Layer::representingVolume

(

)

const

get the Volume associated to the layer

resizeAndRepositionLayer()

virtual void Trk::Layer::resizeAndRepositionLayer ( const VolumeBounds & vBounds, const Amg::Vector3D & vCenter, double envelope = 1. )

pure virtual

resize and reposition layer : dedicated for entry layers

resizeLayer()

virtual void Trk::Layer::resizeLayer ( const VolumeBounds & , double  )

pure virtual

private method to set enclosing TrackingVolume, called by friend class only optionally, the layer can be resized to the dimensions of the TrackingVolume

• Bounds of the Surface are resized
• MaterialProperties dimensions are resized
• SubSurface array boundaries are NOT resized resize layer to the TrackingVolume dimensions - to be overloaded by the extended classes

setBinUtility()

void Trk::Layer::setBinUtility

(

const BinUtility *

)

set the BinUtility

setLayerType()

void Trk::Layer::setLayerType

(

int

identifier

)

set the Layer coding

setNextLayer()

void Trk::Layer::setNextLayer

(

const Layer *

)

set the next Layer

setPreviousLayer()

void Trk::Layer::setPreviousLayer

(

const Layer *

)

set the previous Layer

setRef()

void Trk::Layer::setRef

(

double

)

set the reference measure

subSurface() [1/2]

const Trk::Surface * Trk::Layer::subSurface

(

const Amg::Vector2D &

lp

)

const

If no subSurface array is defined or no subSurface can be found to the given Amg::Vector2D, it would return 0.

Definition at line 112 of file Layer.cxx.

                                                                  {
  if (m_surfaceArray) return m_surfaceArray->object(lp);
  return nullptr;
}

subSurface() [2/2]

const Trk::Surface * Trk::Layer::subSurface

(

const Amg::Vector3D &

gp

)

const

If no subSurface array is defined or no subSurface can be found to the given Amg::Vector3D, it would return 0.

Definition at line 107 of file Layer.cxx.

                                                                  {
  if (m_surfaceArray) return m_surfaceArray->object(gp);
  return nullptr;
}

subSurfaceReference()

const Trk::Surface * Trk::Layer::subSurfaceReference

(

unsigned int

idx = 0

)

const

Return a reference sub surface of the layer, usually the first one in the array.

• if an index is given (and the index is in range), this surface is returned

Definition at line 117 of file Layer.cxx.

                                                                      {
  // the reference surface
  const Trk::Surface* referenceSurface = nullptr;
  if (m_surfaceArray) {
    // get a reference surface
    std::span<Trk::Surface const * const> surfaces =  std::as_const(*m_surfaceArray).arrayObjects();
    // get a reference surface
    unsigned int rfSurfaces = surfaces.size();
    if (idx && idx < rfSurfaces) return surfaces[idx];
    // get the first one which is non zero
    for (unsigned int rsf = 0; rsf < rfSurfaces; ++rsf) {
      referenceSurface = surfaces[rsf];
      if (referenceSurface) break;
    }
  }
  return referenceSurface;
}

surfaceArray() [1/2]

SurfaceArray * Trk::Layer::surfaceArray

(

)

Return the entire SurfaceArray, returns nullptr if no SurfaceArray.

surfaceArray() [2/2]

const SurfaceArray * Trk::Layer::surfaceArray

(

)

const

Return the entire SurfaceArray, returns nullptr if no SurfaceArray.

surfaceOnApproach()

const Trk::Surface & Trk::Layer::surfaceOnApproach ( const Amg::Vector3D & pos, const Amg::Vector3D & dir, PropDirection pdir, const BoundaryCheck & bcheck, bool resolveSubSurfaces = 0, const ICompatibilityEstimator * ice = nullptr ) const

virtual

Surface seen on approach - if not defined differently, it is the surfaceRepresentation()

Definition at line 209 of file Layer.cxx.

                                             {
  return surfaceRepresentation();
}

surfaceRepresentation() [1/2]

virtual const Surface & Trk::Layer::surfaceRepresentation ( ) const

pure virtual

Transforms the layer into a Surface representation for extrapolation.

surfaceRepresentation() [2/2]

virtual Surface & Trk::Layer::surfaceRepresentation ( )

pure virtual

thickness()

double Trk::Layer::thickness

(

)

const

Return the Thickness of the Layer.

Member Data Documentation

m_binUtility

const BinUtility* Trk::Layer::m_binUtility = nullptr

protected

Enclosing TrackingVolume.

Definition at line 300 of file Layer.h.

m_enclosingDetachedTrackingVolume

const DetachedTrackingVolume* Trk::Layer::m_enclosingDetachedTrackingVolume = nullptr

protected

Definition at line 304 of file Layer.h.

m_enclosingTrackingVolume

const TrackingVolume* Trk::Layer::m_enclosingTrackingVolume = nullptr

protected

Enclosing DetachedTrackingVolume.

Definition at line 302 of file Layer.h.

m_index

LayerIndex Trk::Layer::m_index {-1}

protected

LayerIndex.

Definition at line 306 of file Layer.h.

{-1};  

m_layerMaterialProperties

std::unique_ptr<LayerMaterialProperties> Trk::Layer::m_layerMaterialProperties {}

protected

thickness of the Layer

Definition at line 288 of file Layer.h.

{};

m_layerThickness

double Trk::Layer::m_layerThickness {}

protected

descriptor for overlap/next surface (owning ptr)

Definition at line 290 of file Layer.h.

{};

m_layerType

int Trk::Layer::m_layerType {Trk::active}

protected

active passive layer

Definition at line 307 of file Layer.h.

{Trk::active}; 

m_nextLayer

const Layer* Trk::Layer::m_nextLayer = nullptr

protected

BinUtility for next/previous decision.

Definition at line 298 of file Layer.h.

m_overlapDescriptor

std::unique_ptr<OverlapDescriptor> Trk::Layer::m_overlapDescriptor {}

protected

Definition at line 292 of file Layer.h.

{};

m_previousLayer

const Layer* Trk::Layer::m_previousLayer = nullptr

protected

< the previous Layer according to BinGenUtils

next Layer according to BinGenUtils

Definition at line 296 of file Layer.h.

m_ref

double Trk::Layer::m_ref {}

protected

reference measure for local coordinate convertors

Definition at line 308 of file Layer.h.

{};  

m_surfaceArray

std::unique_ptr<SurfaceArray> Trk::Layer::m_surfaceArray {}

protected

MaterialPoperties of this layer Surface.

Definition at line 286 of file Layer.h.

{};

---

The documentation for this class was generated from the following files:

• Layer.h
• Layer.cxx