Trk::TrackingVolumeHelper Class Reference

The TrackingVolumeHelper is a simple Tool that helps to construct volumes mainly for gap regions in the fully connective geometry. More...

#include <TrackingVolumeHelper.h>

Inheritance diagram for Trk::TrackingVolumeHelper:

Collaboration diagram for Trk::TrackingVolumeHelper:

Public Member Functions
	TrackingVolumeHelper (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual	~TrackingVolumeHelper ()
	Destructor.
StatusCode	initialize () override
	AlgTool initialize method.
void	glueTrackingVolumes (TrackingVolume &firstVol, BoundarySurfaceFace firstFace, TrackingVolume &secondVol, BoundarySurfaceFace secondFace, bool buildBoundaryLayer=false) const override
	Method to glue two Volumes together input:
void	glueTrackingVolumes (TrackingVolume &firstVol, BoundarySurfaceFace firstFace, const std::vector< TrackingVolume * > &secondVolumes, BoundarySurfaceFace secondFace, bool buildBoundaryLayer=false, bool boundaryFaceExchange=false) const override
	Method to glue two Volumes together input:
void	glueTrackingVolumes (const std::vector< TrackingVolume * > &firstVolumes, BoundarySurfaceFace firstFace, const std::vector< TrackingVolume * > &secondVolumes, BoundarySurfaceFace secondFace, bool buildBoundaryLayer=false, bool boundaryFaceExchange=false) const override
	Method to glue two VolumeArrays together (at navigation level) - without output.
std::unique_ptr< Trk::TrackingVolume >	glueTrackingVolumeArrays (std::shared_ptr< TrackingVolume > firstVol, BoundarySurfaceFace firstFace, std::shared_ptr< TrackingVolume > secondVol, BoundarySurfaceFace secondFace, const std::string &name) const override
	Method to glue two VolumeArrays together (at navigation level)
void	setInsideTrackingVolume (TrackingVolume &tvol, BoundarySurfaceFace face, TrackingVolume *insidevol) const override
	protected method to set inside Volume of a BoundarySurface: input:
void	setInsideTrackingVolumeArray (TrackingVolume &tvol, BoundarySurfaceFace face, std::shared_ptr< BinnedArray< TrackingVolume > > insidevolarray) const override
	protected method to set inside VolumeArray of a BoundarySurface: input:
void	setOutsideTrackingVolume (TrackingVolume &tvol, BoundarySurfaceFace face, TrackingVolume *outsidevol) const override
	protected method to set outside Volume of a BoundarySurface: input:
void	setOutsideTrackingVolumeArray (TrackingVolume &tvol, BoundarySurfaceFace face, std::shared_ptr< BinnedArray< TrackingVolume > > outsidevolarray) const override
	protected method to set outside VolumeArray of a BoundarySurface: input:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (ITrackingVolumeHelper, 1, 0)
	Creates the InterfaceID and interfaceID() method.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
void	glueVolumes (TrackingVolume &firstVol, BoundarySurfaceFace firstFace, TrackingVolume &secondVol, BoundarySurfaceFace secondFace) const
	protected method to glue two Volumes together input:
void	associateLayer (const Layer &lay, Surface &sf) const
	Protected method to register the Layer to the Surface.

Static Protected Member Functions
static void	setBoundarySurface (TrackingVolume &tvol, std::shared_ptr< BoundarySurface< TrackingVolume > > bsurf, BoundarySurfaceFace face)
	protected method to set the boundary surface of a tracking volume
static void	setInsideVolume (TrackingVolume &tvol, BoundarySurfaceFace face, TrackingVolume *insidevol)
	protected method to set inside Volume of a BoundarySurface: input:
static void	setInsideVolumeArray (TrackingVolume &tvol, BoundarySurfaceFace face, const std::shared_ptr< BinnedArray< TrackingVolume > > &insidevolarray)
	protected method to set inside VolumeArray of a BoundarySurface: input:
static void	setOutsideVolume (TrackingVolume &tvol, BoundarySurfaceFace face, TrackingVolume *outsidevol)
	protected method to set outside Volume of a BoundarySurface: input:
static void	setOutsideVolumeArray (TrackingVolume &tvol, BoundarySurfaceFace face, const std::shared_ptr< BinnedArray< TrackingVolume > > &outsidevolarray)
	protected method to set outside VolumeArray of a BoundarySurface: input:
static void	confineVolume (TrackingVolume &tvol, TrackingVolume *outsidevol)
	protected method to confine (dense) volumes: input:

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< Trk::LayerMaterialProperties >	layerMaterialProperties (const Trk::Surface &sf) const
	< helper method to construct barrel material
void	glueTrackingVolumes (const std::vector< std::shared_ptr< TrackingVolume > > &glueVols, BoundarySurfaceFace glueFace, BoundarySurfaceFace secondFace) const
	Execute the glueing - the input volumes are all on navigation level.
void	glueTrackingVolumes (const std::vector< TrackingVolume * > &glueVols, BoundarySurfaceFace glueFace, BoundarySurfaceFace secondFace) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	fillGlueVolumes (const std::vector< TrackingVolume * > &topLevelVolumes, const std::vector< TrackingVolume * > &envelopeFaceVolumes, BoundarySurfaceFace glueFace, std::vector< Trk::TrackingVolume * > &glueVols)
	Private method - it takes the full vector of given volumes to create the supervolume,.
static void	fillGlueVolumes (const std::vector< std::shared_ptr< TrackingVolume > > &topLevelVolumes, const std::vector< std::shared_ptr< TrackingVolume > > &envelopeFaceVolumes, BoundarySurfaceFace glueFace, std::vector< Trk::TrackingVolume * > &glueVols)

Private Attributes
PublicToolHandle< ILayerArrayCreator >	m_layerArrayCreator {this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}
	A Tool for coherent LayerArray creation.
ToolHandle< ITrackingVolumeArrayCreator >	m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}
	Helper Tool to create TrackingVolume.
Gaudi::Property< int >	m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 1}
	material bins in Z
Gaudi::Property< int >	m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}
	material bins in Phi
Gaudi::Property< int >	m_endcapLayerBinsR {this, "EndcapLayerBinsR", 1}
	material bins in R
Gaudi::Property< int >	m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}
	material bins in Phi
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr double	s_layerThickness
	standard layer thickness

Detailed Description

The TrackingVolumeHelper is a simple Tool that helps to construct volumes mainly for gap regions in the fully connective geometry.

Author

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

Definition at line 53 of file TrackingVolumeHelper.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrackingVolumeHelper()

Trk::TrackingVolumeHelper::TrackingVolumeHelper	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Constructor.

Definition at line 50 of file TrackingVolumeHelper.cxx.

: AthAlgTool(t,n,p),
  TrackingVolumeManipulator() {
    declareInterface<ITrackingVolumeHelper>(this);
}

~TrackingVolumeHelper()

Trk::TrackingVolumeHelper::~TrackingVolumeHelper ( )

virtualdefault

Destructor.

Member Function Documentation

associateLayer()

void Trk::ITrackingVolumeHelper::associateLayer ( const Layer & lay, Surface & sf ) const

inlineprotectedinherited

Protected method to register the Layer to the Surface.

Definition at line 127 of file ITrackingVolumeHelper.h.

  {
    sf.associateLayer(lay);
  }

confineVolume()

void Trk::TrackingVolumeManipulator::confineVolume ( TrackingVolume & tvol, TrackingVolume * outsidevol )

staticprotectedinherited

protected method to confine (dense) volumes: input:

• the volume that holdes the BoundarySurfaces (embedded)
• the volume to be set as outside volume

Definition at line 90 of file TrackingVolumeManipulator.cxx.

{
 
  const auto& bounds = tvol.boundarySurfaces();
  for (const auto & bound : bounds) {
    if (bound->outsideVolume() == nullptr) {
      bound->setOutsideVolume(outsideVol);
    }
    if (bound->insideVolume() == nullptr) {
      bound->setInsideVolume(outsideVol);
    }
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

Trk::ITrackingVolumeHelper::DeclareInterfaceID ( ITrackingVolumeHelper , 1 , 0  )

inherited

Creates the InterfaceID and interfaceID() method.

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fillGlueVolumes() [1/2]

void Trk::TrackingVolumeHelper::fillGlueVolumes ( const std::vector< std::shared_ptr< TrackingVolume > > & topLevelVolumes, const std::vector< std::shared_ptr< TrackingVolume > > & envelopeFaceVolumes, BoundarySurfaceFace glueFace, std::vector< Trk::TrackingVolume * > & glueVols )

staticprivate

Definition at line 556 of file TrackingVolumeHelper.cxx.

                                                                                {
    std::vector<std::shared_ptr<TrackingVolume>> sharedTops{};
    std::vector<std::shared_ptr<TrackingVolume>> sharedFaces{};
    return fillGlueVolumes(::toRawVec(topLevelVolumes),
                           ::toRawVec(envelopeFaceVolumes),
                           glueFace, glueVols);
 
}

fillGlueVolumes() [2/2]

void Trk::TrackingVolumeHelper::fillGlueVolumes ( const std::vector< TrackingVolume * > & topLevelVolumes, const std::vector< TrackingVolume * > & envelopeFaceVolumes, BoundarySurfaceFace glueFace, std::vector< Trk::TrackingVolume * > & glueVols )

staticprivate

Private method - it takes the full vector of given volumes to create the supervolume,.

• it compares the volumes with the ones scheduled to build the face (could probably be done at once)
• it checks whether there is a sub-structure (i.e. GlueVolumeDescriptor exists) and adds either the volume itself or the associated subvolume
• volumes on glueVols level are all on navigation level

Definition at line 567 of file TrackingVolumeHelper.cxx.

                                                                                 {
    // loop over the topLevel Volumes
    auto refVolIter = topLevelVolumes.begin();
    for ( ; refVolIter != topLevelVolumes.end(); ++refVolIter ) {
        // loop over the faceVolumes
        for (auto *envelopeFaceVolume : envelopeFaceVolumes){
            // check whether this volume was assigned to on this face
            if (envelopeFaceVolume==(*refVolIter)) {
                // get the GlueVolumesDescriptor
                GlueVolumesDescriptor& glueVolDescriptor = (*refVolIter)->glueVolumesDescriptor();
                // if the size of glue volumes is 0 -> the referenceVolume is at navigation level
                if ( (glueVolDescriptor.glueVolumes(glueFace)).empty()) {
                    glueVols.push_back(*refVolIter);
                } else {
                    // fill all the sub-volumes described by the glueVolumeDescriptor
                    for (auto *isubNavVol : glueVolDescriptor.glueVolumes(glueFace))
                        glueVols.push_back( isubNavVol  );
                }
            }
        }// loop over envelopeFaceVolumes
    } // loop over reference Volumes
}

glueTrackingVolumeArrays()

std::unique_ptr< TrackingVolume > Trk::TrackingVolumeHelper::glueTrackingVolumeArrays ( std::shared_ptr< TrackingVolume > firstVol, BoundarySurfaceFace firstFace, std::shared_ptr< TrackingVolume > secondVol, BoundarySurfaceFace secondFace, const std::string & name ) const

overridevirtual

Method to glue two VolumeArrays together (at navigation level)

• relies on information from glueDescriptor input:
• first TrackingVolume
• face of the BoundarySurface of the first volume
• second volume that gets glued to the first volume
• face of the BoundarySurface of the second volume output:
  • returns enveloping TrackingVolume with glueDescription set for consequent gluing

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 408 of file TrackingVolumeHelper.cxx.

                                                                                                            {
    std::unique_ptr<TrackingVolume> enclosingVolume{};
 
    const auto *cyl1 = dynamic_cast<const CylinderVolumeBounds*>(&(firstVol->volumeBounds()));
    const auto *cyl2 = dynamic_cast<const CylinderVolumeBounds*>(&(secondVol->volumeBounds()));
 
    if (!cyl1 || !cyl2) {
        ATH_MSG_ERROR( "TrackingVolumeHelper::glueTrackingVolumeArrays: input volumes not cylinders, return 0" );
        return enclosingVolume;
    }
    if (cyl1->halfPhiSector()!= M_PI || cyl2->halfPhiSector()!= M_PI ) {
        ATH_MSG_ERROR( "TrackingVolumeHelper::glueTrackingVolumeArrays: not coded for cylinder Phi sectors yet, return 0" );
        return enclosingVolume;
    }
 
    // if the swap is required
    BoundarySurfaceFace firstFaceCorr = firstFace;
    BoundarySurfaceFace secondFaceCorr = secondFace;
 
 
    // build volume envelope
    std::vector<std::shared_ptr<TrackingVolume>> vols;
    std::shared_ptr<CylinderVolumeBounds> envBounds{};
    std::unique_ptr<Amg::Transform3D> envTransf{};
    std::unique_ptr<BinnedArray<TrackingVolume>>  subVols{};
    vols.push_back(firstVol);
    vols.push_back(secondVol);
    std::vector<std::shared_ptr<TrackingVolume>> envGlueNegXY{};
    std::vector<std::shared_ptr<TrackingVolume>> envGluePosXY{};
    std::vector<std::shared_ptr<TrackingVolume>> envGlueOuter;
    std::vector<std::shared_ptr<TrackingVolume>> envGlueInner{};
 
    if (firstFace==positiveFaceXY) {
        envBounds =  std::make_shared<CylinderVolumeBounds>(cyl1->innerRadius(),
                                                                 cyl1->outerRadius(),
                                                                 cyl1->halflengthZ() + cyl2->halflengthZ());
 
        const Amg::Vector3D center{firstVol->center()};
        envTransf = std::make_unique<Amg::Transform3D>(Amg::getTranslate3D(center.x(),
                                                                           center.y(),
                                                                           center.z() + cyl2->halflengthZ()));
 
        subVols = m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(vols, false);
        envGlueNegXY.push_back(firstVol);
        envGluePosXY.push_back(secondVol);
        envGlueOuter = vols;
        envGlueInner = vols;
    } else if (firstFace==negativeFaceXY) {
        envBounds =  std::make_shared<CylinderVolumeBounds>(cyl1->innerRadius(),
                                                                 cyl1->outerRadius(),
                                                                 cyl1->halflengthZ()+cyl2->halflengthZ());
        const Amg::Vector3D center{firstVol->center()};
        envTransf = std::make_unique<Amg::Transform3D>(Amg::getTranslate3D(center.x(),
                                                                           center.y(),
                                                                           center.z() - cyl2->halflengthZ()));
        envGlueNegXY.push_back(secondVol);
        envGluePosXY.push_back(firstVol);
        // revert vols
        vols.clear();
        vols.push_back(secondVol);
        vols.push_back(firstVol);
        // --- account for the swapping
        firstFaceCorr = secondFace;
        secondFaceCorr = firstFace;
        //
        subVols = m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(vols,false);
        envGlueOuter = vols;
        envGlueInner = vols;
    } else if (firstFace==tubeInnerCover) {
        if (secondFace==tubeOuterCover){
            envBounds =  std::make_shared<CylinderVolumeBounds>(cyl2->innerRadius(),
                                                                     cyl1->outerRadius(),
                                                                     cyl1->halflengthZ());
        } else {
            envBounds =  std::make_shared<CylinderVolumeBounds>(cyl1->outerRadius(),
                                                                     cyl1->halflengthZ());
        }
        if (!firstVol->transform().isApprox(Amg::Transform3D::Identity())) {
            envTransf = std::make_unique<Amg::Transform3D>(Amg::getTranslate3D(firstVol->center()));
        }
        // revert vols
        vols.clear();
        vols.push_back(secondVol);
        vols.push_back(firstVol);
        // account for the swapping
        firstFaceCorr = secondFace;
        secondFaceCorr = firstFace;
        //
        subVols = m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(vols,false);
        envGlueNegXY = vols;
        envGluePosXY = vols;
        envGlueOuter.push_back(firstVol);
        envGlueInner.push_back(secondVol);
    } else {
        envBounds =  std::make_shared<CylinderVolumeBounds>(cyl1->innerRadius(),
                                                                 cyl2->outerRadius(),
                                                                 cyl1->halflengthZ());
        if(!firstVol->transform().isApprox(Amg::Transform3D::Identity())){
           envTransf = std::make_unique<Amg::Transform3D>(Amg::getTranslate3D(firstVol->center()));
        }
        subVols = m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(vols, false);
        envGlueNegXY = vols;
        envGluePosXY = vols;
        envGlueOuter.push_back(secondVol);
        envGlueInner.push_back(firstVol);
        // account for the swapping
        firstFaceCorr = secondFace;
        secondFaceCorr = firstFace;
    }
 
    // create the enveloping volume
    enclosingVolume  =  std::make_unique<TrackingVolume>(std::move(envTransf),
                                                         envBounds,
                                                         *firstVol,
                                                         nullptr, std::move(subVols), name);
 
    // ENVELOPE GLUE DESCRIPTION -----------------------------------------------------------------
    // glue descriptors ---- they jump to the first one
    GlueVolumesDescriptor& glueDescr  = enclosingVolume->glueVolumesDescriptor();
 
    // for the outside volumes, could be done in a loop as well, but will only save 4 lines
    std::vector<TrackingVolume*> glueNegXY{};
    std::vector<TrackingVolume*> gluePosXY{};
    std::vector<TrackingVolume*> glueInner{};
    std::vector<TrackingVolume*> glueOuter{};
    fillGlueVolumes(vols, envGlueNegXY, negativeFaceXY,glueNegXY);
    fillGlueVolumes(vols, envGluePosXY, positiveFaceXY,gluePosXY);
    fillGlueVolumes(vols, envGlueInner, tubeInnerCover,glueInner);
    fillGlueVolumes(vols, envGlueOuter, tubeOuterCover,glueOuter);
    // set them to the envelopGlueDescriptor
    glueDescr.registerGlueVolumes(negativeFaceXY, glueNegXY);
    glueDescr.registerGlueVolumes(positiveFaceXY, gluePosXY);
    glueDescr.registerGlueVolumes(tubeInnerCover, glueInner);
    glueDescr.registerGlueVolumes(tubeOuterCover, glueOuter);
    glueDescr.registerGlueVolumes(cylinderCover,  glueOuter);
 
    // INTERNAL GLUEING ---------------------------------------------------------------------------
    glueTrackingVolumes(vols, firstFaceCorr, secondFaceCorr);
 
    return enclosingVolume;
}

glueTrackingVolumes() [1/5]

void Trk::TrackingVolumeHelper::glueTrackingVolumes ( const std::vector< std::shared_ptr< TrackingVolume > > & glueVols, BoundarySurfaceFace glueFace, BoundarySurfaceFace secondFace ) const

private

Execute the glueing - the input volumes are all on navigation level.

Definition at line 595 of file TrackingVolumeHelper.cxx.

                                                                                     {
    glueTrackingVolumes(::toRawVec(glueVols), firstFace, secondFace);
 
}

glueTrackingVolumes() [2/5]

void Trk::TrackingVolumeHelper::glueTrackingVolumes ( const std::vector< TrackingVolume * > & firstVolumes, BoundarySurfaceFace firstFace, const std::vector< TrackingVolume * > & secondVolumes, BoundarySurfaceFace secondFace, bool buildBoundaryLayer = false, bool boundaryFaceExchange = false ) const

overridevirtual

Method to glue two VolumeArrays together (at navigation level) - without output.

Simply forward to base class method to enhance friendship relation.

• relies on information from glueDescriptor input:
• first TrackingVolume array
• face of the BoundarySurface of the first volume
• second TrackingVolume array
• face of the BoundarySurface of the second volume

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 190 of file TrackingVolumeHelper.cxx.

{
 
 
    std::unique_ptr<BinnedArray<TrackingVolume>> navArrayOne = nullptr;
    std::unique_ptr<BinnedArray<TrackingVolume>> navArrayTwo = nullptr;
 
    std::unique_ptr<Surface>     mLayerSurface;
    std::shared_ptr<MaterialLayer>       mLayer;
 
    ATH_MSG_VERBOSE("Glue configuration firstFace | secondFace = " << firstFace << " | " << secondFace );
 
    // create the Arrays - assuming cylindrical TrackingVolumes
    if (firstFace < 2 && secondFace < 2 ) {
        ATH_MSG_VERBOSE( "The glueing is done along z axis" );
        navArrayOne = m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(firstVolumes, true);
        navArrayTwo = m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(secondVolumes, true);
        // build a disc to separate the two
        if (buildBoundaryLayer || boundaryFaceExchange){
            double rmin = 10e10; double rmax = 0; double boundaryz = 0.; double centerzOne = 0.;
            for (const auto & volIter : firstVolumes ){
                const CylinderVolumeBounds* cb = dynamic_cast<const CylinderVolumeBounds*>(&(volIter->volumeBounds()));
                if (cb) {
                    takeSmaller(rmin,cb->innerRadius());
                    takeBigger(rmax,cb->outerRadius());
                    // get the z of the surface
                    boundaryz = volIter->boundarySurfaces()[firstFace]->surfaceRepresentation().center().z();
                }
                centerzOne = volIter->center().z();
            }
            if (buildBoundaryLayer){
              Amg::Transform3D mLayerTransform =
                Amg::Transform3D(Amg::Translation3D(0., 0., boundaryz));
              // layer surface
              mLayerSurface = std::make_unique<DiscSurface>(mLayerTransform, rmin, rmax);
              // create a MaterialLayer
              std::unique_ptr<LayerMaterialProperties> lmps = layerMaterialProperties(*mLayerSurface);
              // MaterialLayer clones the LayerMaterialPropteries.
 
              if (lmps) {
                mLayer = std::make_shared<MaterialLayerOwnSurf>(std::move(mLayerSurface), std::move(lmps));
              }
            }
            if (boundaryFaceExchange){
                // creating only one boundary surface
                ATH_MSG_VERBOSE("Creating a joint boundary surface for n-to-n glueing case.");
                // check if the seconf volumes have a bigger z value or a smaller one
                double centerzTwo = secondVolumes[secondVolumes.size()-1]->center().z();
                // thi sboundary surface is having a z-axix along the global z-axis
                Amg::Transform3D boundaryTransform = Amg::getTranslateZ3D(boundaryz);
                // disc surfaces
                DiscSurface dSurface(boundaryTransform, rmin, rmax);
                // swap if needed
                if (centerzTwo < centerzOne){
                    std::swap(navArrayTwo, navArrayOne);
                }
                // create the new boudnary surface which spans over the entire volume border
                std::shared_ptr< BinnedArray<TrackingVolume> >  navArrayInside(std::move(navArrayOne));
                std::shared_ptr< BinnedArray<TrackingVolume> >  navArrayOutside(std::move(navArrayTwo));
                BoundaryDiscSurface<TrackingVolume>* boundarySurface = new BoundaryDiscSurface<TrackingVolume>(navArrayInside,navArrayOutside,dSurface);
                std::shared_ptr<BoundarySurface<TrackingVolume> > sharedBoundarySurface(boundarySurface);
                // attach the material layer to the shared boundary if existing
                if (mLayer) {
                    ATH_MSG_VERBOSE( "Set MaterialLayer to the BoundarySurface of volume from second array." );
                    boundarySurface->surfaceRepresentation().setMaterialLayer(mLayer);
                }
                // set the boundary surface to the volumes of both sides
                for (const auto & volIter : firstVolumes){
                    ATH_MSG_VERBOSE("  -> first array : setting a newly created boundary surface to  " << volIter->volumeName());
                    setBoundarySurface(*volIter,sharedBoundarySurface,firstFace);
                }
                for (const auto & volIter : secondVolumes){
                    ATH_MSG_VERBOSE("  -> second array : setting a newly created boundary surface to  " << volIter->volumeName());
                    setBoundarySurface(*volIter,sharedBoundarySurface,secondFace);
                }
                // we are done here
                return;
            }
        }
    } else {
        ATH_MSG_VERBOSE( "The glueing is done along the radius." );
        navArrayOne = m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(firstVolumes, true);
        navArrayTwo = m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(secondVolumes, true);
        // check if the boundary layer was configured to be built
        if (buildBoundaryLayer || boundaryFaceExchange){
            // build a cylinder to separate the two
            double zmin = 10e10; double zmax = -10e10; double boundaryr = 0.; double volumerOne = 0.; double volumerTwo = 10e10;
            for (const auto & volIter : firstVolumes ){
                const CylinderVolumeBounds* cb = dynamic_cast<const CylinderVolumeBounds*>(&(volIter->volumeBounds()));
                if (cb) {
                    takeSmaller(zmin,volIter->center().z()-cb->halflengthZ());
                    takeBigger(zmax,volIter->center().z()+cb->halflengthZ());
                    // get the z of the surface
                    boundaryr = volIter->boundarySurfaces()[firstFace]->surfaceRepresentation().bounds().r();
                    // get the volume radius
                    volumerOne = cb->outerRadius();
                }
            }
            // check if boundary layer should be built
            if (buildBoundaryLayer){
              std::unique_ptr<Amg::Transform3D> mLayerTransform =
                ((zmin + zmax) * (zmin + zmax) < 10e-4)
                  ? nullptr
                  : std::make_unique < Amg::Transform3D>();
 
              if (mLayerTransform) (*mLayerTransform) = Amg::Translation3D(0.,0.,0.5*(zmin+zmax));
                mLayerSurface.reset( mLayerTransform ? new CylinderSurface(*mLayerTransform,boundaryr,0.5*(zmax-zmin))  :
                                     new CylinderSurface(boundaryr,0.5*(zmax-zmin)) );
                // create a MaterialLayer
                std::unique_ptr<LayerMaterialProperties>  lmps = layerMaterialProperties(*mLayerSurface);
                // LayerMaterialProperties will be cloned in MaterialLayer
                if (lmps) mLayer = std::make_shared<MaterialLayerOwnSurf>(
                  std::move(mLayerSurface),
                  std::move(lmps) );
            }
            // check if boundary face should be exchanged
            if (boundaryFaceExchange) {
                // creating only one boundary surface
                ATH_MSG_VERBOSE("Creating a joint boundary surface for n-to-n glueing case.");
                // the boundary transform can be 0 for cylinder surfaces
                std::unique_ptr<Amg::Transform3D> boundaryTransform =
                  ((zmin + zmax) * (zmin + zmax) < 10e-4)
                    ? nullptr
                    : std::make_unique<Amg::Transform3D>();
 
                if (boundaryTransform) (*boundaryTransform) = Amg::getTranslateZ3D(0.5*(zmin+zmax));
                // create the cylinder surface for the shared boundary
                CylinderSurface cSurface = boundaryTransform ? CylinderSurface(*boundaryTransform,boundaryr,0.5*(zmax-zmin)) :
                                                               CylinderSurface(boundaryr,0.5*(zmax-zmin));
                // get the volume outer radius of the sconf volumes
                const CylinderVolumeBounds* cbTwo = dynamic_cast<const CylinderVolumeBounds*>(&(secondVolumes[secondVolumes.size()-1]->volumeBounds()));
                if (cbTwo){
                    volumerTwo = cbTwo->outerRadius();
                }
                // swap if needed
                if (volumerTwo < volumerOne){
                  std::swap(navArrayTwo, navArrayOne);
                }
                // create the new boudnary surface which spans over the entire volume border
                std::shared_ptr< BinnedArray<TrackingVolume> >  navArrayInside(std::move(navArrayOne));
                std::shared_ptr< BinnedArray<TrackingVolume> >  navArrayOutside(std::move(navArrayTwo));
                BoundaryCylinderSurface<TrackingVolume>* boundarySurface = new BoundaryCylinderSurface<TrackingVolume>(navArrayInside,navArrayOutside,cSurface);
                std::shared_ptr<BoundarySurface<TrackingVolume> > sharedBoundarySurface(boundarySurface);
                // attach the material layer to the shared boundary if existing
                if (mLayer) {
                  ATH_MSG_VERBOSE("Set MaterialLayer to the BoundarySurface of volume from second array.");
                  // assume that now the mlayer onwership goes over to the TrackingVolume
                  boundarySurface->surfaceRepresentation().setMaterialLayer(mLayer);
                }
                // set the boundary surface to the volumes of both sides
                for (const auto & volIter : firstVolumes){
                    ATH_MSG_VERBOSE("  -> first array : setting a newly created boundary surface to  " << volIter->volumeName());
                    setBoundarySurface(*volIter,sharedBoundarySurface,firstFace);
                }
                for (const auto & volIter : secondVolumes){
                    ATH_MSG_VERBOSE("  -> second array : setting a newly created boundary surface to  " << volIter->volumeName());
                    setBoundarySurface(*volIter,sharedBoundarySurface,secondFace);
                }
                // we are done here
                return;
            }
        } // build either boundary layer or exchange the face
    } // radial glueing
 
 
    // create the boundary faces - not creating a joint one
    ATH_MSG_VERBOSE("Leaving individual boundary surfaces for n-to-n glueing case.");
 
    // assign the navigation arrays
    std::shared_ptr< BinnedArray< TrackingVolume> > navArrayOneShared(std::move(navArrayOne));
    std::shared_ptr< BinnedArray< TrackingVolume> > navArrayTwoShared(std::move(navArrayTwo));
 
    // (a) to the first set of volumes
    for (const auto & tVolIter: firstVolumes) {
        // take care of the orientation of the normal vector
        if (firstFace != tubeInnerCover) {
            setOutsideTrackingVolumeArray(*tVolIter,firstFace,navArrayTwoShared);
            ATH_MSG_VERBOSE( "Set outsideTrackingVolumeArray at face " << firstFace << " to " << (*tVolIter).volumeName() );
        } else {
            setInsideTrackingVolumeArray(*tVolIter,firstFace,navArrayTwoShared);
            ATH_MSG_VERBOSE( "Set insideTrackingVolumeArray at face " << firstFace << " to " << (*tVolIter).volumeName() );
        }
        // set the boundary layer if it exists
        if (mLayer) {
            ATH_MSG_VERBOSE( "Set MaterialLayer to the BoundarySurface of volume from first array." );
            Surface& firstFaceSurface = tVolIter->boundarySurfaces()[firstFace]->surfaceRepresentation();
            // assume that now the mlayer onwership goes over to the TrackingVolume
            //cppcheck-suppress ignoredReturnValue
            firstFaceSurface.setMaterialLayer(mLayer);
        }
 
    }
    // (b) to the second set of volumes
    for (const auto & tVolIter : secondVolumes) {
        // take care of the orientation of the normal vector
        if (secondFace != tubeInnerCover) {
            ATH_MSG_VERBOSE( "Set outsideTrackingVolumeArray at face " << secondFace << " to " << (*tVolIter).volumeName() );
            setOutsideTrackingVolumeArray(*tVolIter,secondFace,navArrayOneShared);
        } else {
            ATH_MSG_VERBOSE( "Set insideTrackingVolumeArray at face " << secondFace << " to " << (*tVolIter).volumeName() );
            setInsideTrackingVolumeArray(*tVolIter,secondFace,navArrayOneShared);
        }
        if (mLayer) {
            ATH_MSG_VERBOSE( "Set MaterialLayer to the BoundarySurface of volume from second array." );
            Surface& secondFaceSurface = tVolIter->boundarySurfaces()[secondFace]->surfaceRepresentation();
            // assume that now the mlayer onwership goes over to the TrackingVolume
            //cppcheck-suppress ignoredReturnValue
            secondFaceSurface.setMaterialLayer(mLayer);
        }
    }
    // coverity will report a bug here for mLayer running out of scope, but the memory management is done later in the TrackingVolume
}

glueTrackingVolumes() [3/5]

void Trk::TrackingVolumeHelper::glueTrackingVolumes ( const std::vector< TrackingVolume * > & glueVols, BoundarySurfaceFace glueFace, BoundarySurfaceFace secondFace ) const

private

Definition at line 601 of file TrackingVolumeHelper.cxx.

                                                                                     {
 
    if (glueVols.size()<2) {
        ATH_MSG_VERBOSE( "Nothing to do in glueVolumes() " );
        return;
    }
 
 
    ATH_MSG_VERBOSE( " glueTrackingVolumes() called with boundary faces " << static_cast<int>(firstFace)
                    << " and " << static_cast<int>(secondFace) << "." );
 
    // the iterators through the volumes
    std::vector<TrackingVolume*>::const_iterator firstVol  = glueVols.begin();
    std::vector<TrackingVolume*>::const_iterator secondVol = firstVol + 1;
    for ( ; secondVol != glueVols.end(); ++firstVol, ++secondVol) {
 
        if (msgLvl(MSG::VERBOSE))
            ATH_MSG_VERBOSE( "Processing '" << (*firstVol)->volumeName() << "' and '" << (*secondVol)->volumeName() << "'." );
 
        // get the glue volume descriptors to see that we have all subvolumes
        GlueVolumesDescriptor& glueDescr1 = (*firstVol)->glueVolumesDescriptor();
        GlueVolumesDescriptor& glueDescr2 = (*secondVol)->glueVolumesDescriptor();
 
        // glue volumes at navigation level
        std::vector<TrackingVolume*> glueVols1{};
        std::vector<TrackingVolume*> glueVols2{};
        glueVols1 = glueDescr1.glueVolumes(firstFace);
        glueVols2 = glueDescr2.glueVolumes(secondFace);
 
        // trivial cases
        // (glue one to the other)
        if (glueVols1.empty() && glueVols2.empty()) {
            glueTrackingVolumes(**firstVol,firstFace,**secondVol,secondFace);
            continue;
            // (glue one to many)
        } else if (glueVols1.empty() && !glueVols2.empty()) {
            glueVols1.push_back(*firstVol);
            // (glue the other one to many)
        } else if (!glueVols1.empty() && glueVols2.empty()) {
            glueVols2.push_back(*secondVol);
        }
 
        // non-trivial case :: array against array
        // in Z : assume 2dim R/Phi
        if (firstFace==negativeFaceXY || firstFace==positiveFaceXY ) {
            // turn both vectors into R/Phi 2dim binnedArrays; assume equidistant binning in Phi
            std::shared_ptr<BinnedArray<TrackingVolume>> sgv1{m_trackingVolumeArrayCreator->cylinderVolumesArrayInPhiR(glueVols1,true)};
            std::shared_ptr<BinnedArray<TrackingVolume>> sgv2{m_trackingVolumeArrayCreator->cylinderVolumesArrayInPhiR(glueVols2,true)};
 
            // array vs. array in Z
            if (glueVols2.size()>1)
                for (auto & vol : glueVols1) setOutsideTrackingVolumeArray( *vol, firstFace, sgv2 );
            else
                for (auto & vol : glueVols1) setOutsideTrackingVolume( *vol, firstFace, glueVols2[0] );
 
            if (glueVols1.size()>1)
                for (auto & vol : glueVols2) setOutsideTrackingVolumeArray( *vol, secondFace, sgv1 );
            else
                for (auto & vol : glueVols2) setOutsideTrackingVolume( *vol, secondFace, glueVols1[0] );
 
 
        } else {
            // turn both vectors into Z/Phi 2dim binnedArrays; assume equidistant binning in Phi
            std::shared_ptr<BinnedArray<TrackingVolume>> sgv1{m_trackingVolumeArrayCreator->cylinderVolumesArrayInPhiZ(glueVols1,true)};
            std::shared_ptr<BinnedArray<TrackingVolume>> sgv2{m_trackingVolumeArrayCreator->cylinderVolumesArrayInPhiZ(glueVols2,true)};
 
            // the glue cases -----------------------------------------------------------------------------------
            // handle the tube with care !
            // first vol
            for (auto & vol : glueVols1) {
                // set the array as the outside array of the firstVol
                if (firstFace != tubeInnerCover) {
                    if (glueVols2.size()>1)
                        setOutsideTrackingVolumeArray( *vol, firstFace, sgv2 );
                    else
                        setOutsideTrackingVolume( *vol, firstFace, glueVols2[0] );
                } else {
                    if (glueVols2.size()>1){
                        setInsideTrackingVolumeArray( *vol, firstFace, sgv2 );
                        setOutsideTrackingVolume( *vol, firstFace, vol );
                    } else {
                        setInsideTrackingVolume( *vol, firstFace, glueVols2[0] );
                        setOutsideTrackingVolume( *vol, firstFace, vol );
                    }
                }
            }
            // second
            for (auto & vol : glueVols2) {
                // set the array as the outside array of the secondVol
                if (secondFace != tubeInnerCover)
                    setOutsideTrackingVolumeArray( *vol, secondFace, sgv1 );
                else {
                    setInsideTrackingVolumeArray( *vol, secondFace, sgv1 );
                    setOutsideTrackingVolume( *vol, secondFace, vol );
                }
            }
        }
    }
}

glueTrackingVolumes() [4/5]

void Trk::TrackingVolumeHelper::glueTrackingVolumes ( TrackingVolume & firstVol, BoundarySurfaceFace firstFace, const std::vector< TrackingVolume * > & secondVolumes, BoundarySurfaceFace secondFace, bool buildBoundaryLayer = false, bool boundaryFaceExchange = false ) const

overridevirtual

Method to glue two Volumes together input:

Simply forward to base class method to enhance friendship relation.

• first TrackingVolume that keeps boundary surface
• face of the BoundarySurface to be kept
• second volume that gets glued to the first volume
• face of the BoundarySurface to be shared

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 102 of file TrackingVolumeHelper.cxx.

{
 
    if (msgLvl(MSG::VERBOSE)) {
        ATH_MSG_VERBOSE( "Glue Volume '" << firstVol.volumeName() << "' to " << secondVolumes.size() << " volume(s): " );
        for (const auto & volIter : secondVolumes)
            ATH_MSG_VERBOSE( "              -> " << (volIter)->volumeName() );
    }
    // prepare the material layer if needed
    std::shared_ptr<MaterialLayer> mLayer{};
    // ----------------------------------------------------------------------------------------
    // create a MaterialLayer as a boundary
    if (buildBoundaryLayer){
        // the first face surface
        Surface& firstFaceSurface = firstVol.boundarySurfaces()[firstFace]->surfaceRepresentation();
        std::unique_ptr<LayerMaterialProperties> lmps = layerMaterialProperties(firstFaceSurface);
        // LayerMaterialProperties are cloned by MaterialLayer
 
        // the material layer is ready - it can be assigned
        mLayer = std::make_shared<MaterialLayerNoOwnSurf>(&firstFaceSurface, std::move(lmps));
        ATH_MSG_VERBOSE( "Set MaterialLayer to the BoundarySurface of first volume (may be shared with second volume)." );
        firstFaceSurface.setMaterialLayer(mLayer);
    }
    // if only one volume was given in the vector call the standard one-to-one glueing
    // 1-to-1 case
    if (secondVolumes.size() == 1) {
        // self call for one-on-one
        glueTrackingVolumes(firstVol, firstFace, *(secondVolumes[0]), secondFace);
    } else {
        // create the navigation bin array
      std::unique_ptr<BinnedArray<TrackingVolume>> navArray = nullptr;
        // create the Array - either r-binned or z-binned
        if (firstFace == negativeFaceXY || firstFace == positiveFaceXY )
            navArray = m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(secondVolumes, true);
        else
            navArray = m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(secondVolumes, true);
 
        // set the volume array to the first boundary surface - this must always happen
        if (firstFace != tubeInnerCover){
            setOutsideTrackingVolumeArray( firstVol, firstFace, std::move(navArray) );
        }
        else{
            setInsideTrackingVolumeArray( firstVol, firstFace, std::move(navArray) );
        }
        // the navigation arrays are completed now - check if the boundary face should be exchanged
        // [1] the boundary face exchange ----------------------------------------------------------------------------------------
        if (boundaryFaceExchange){
            // creating only one boundary surface
            ATH_MSG_VERBOSE("Creating a joint boundary surface for 1-to-n glueing case.");
            // get the dimension of boundary surface of the first volume
            std::shared_ptr<BoundarySurface<TrackingVolume> > bSurface = firstVol.boundarySurfaces()[firstFace];
            // replace the boundary surface
            for ( const auto & volIter: secondVolumes )
                setBoundarySurface(*volIter, bSurface, secondFace);
        } else {
         // [2] the traditional way, keeping two boundary surfaces
         // now set the face to the volume array -------------------------------------------------------------------------------
            for ( const auto & volIter: secondVolumes ) {
                // the secondGlueFace
                BoundarySurfaceFace secondGlueFace = secondFace;
                if (secondFace == tubeOuterCover) {
                    //check for cylinder case
                    const CylinderVolumeBounds* currentVolBounds = dynamic_cast<const CylinderVolumeBounds*>(&((volIter)->volumeBounds()));
                    // protection : there may be a cylinder within the tube vector
                    if (currentVolBounds && currentVolBounds->innerRadius() < 10e-3)
                        secondGlueFace = cylinderCover;
                    setOutsideTrackingVolume(*volIter, secondGlueFace, (&(firstVol)));
                } // for all surfaces except the tunbeInnerCover outside of the surface is identical to outside of the volume
                else if (secondGlueFace != tubeInnerCover)
                    setOutsideTrackingVolume(*volIter, secondGlueFace, (&(firstVol)));
                else
                    setInsideTrackingVolume(*volIter, secondGlueFace, (&(firstVol)));
                // if existing, set the material Layer
                // get the second face surface and set the new MaterialLayer
                Surface& secondFaceSurface = volIter->boundarySurfaces()[secondFace]->surfaceRepresentation();
                secondFaceSurface.setMaterialLayer(mLayer);
            }
        }
    } // 1-to-n case
}

glueTrackingVolumes() [5/5]

void Trk::TrackingVolumeHelper::glueTrackingVolumes ( TrackingVolume & firstVol, BoundarySurfaceFace firstFace, TrackingVolume & secondVol, BoundarySurfaceFace secondFace, bool buildBoundaryLayer = false ) const

overridevirtual

Method to glue two Volumes together input:

Simply forward to base class method to enhance friendship relation.

• first TrackingVolume that keeps boundary surface
• face of the BoundarySurface to be kept
• second volume that gets glued to the first volume
• face of the BoundarySurface to be shared

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 70 of file TrackingVolumeHelper.cxx.

{
    TrackingVolumeManipulator::glueVolumes( firstVol, firstFace, secondVol, secondFace );
 
    // ----------------------------------------------------------------------------------------
    // create a MaterialLayer as a boundary
    if (buildBoundaryLayer){
        auto& bSurfacesFirst  =  firstVol.boundarySurfaces();
        auto& bSurfacesSecond =  secondVol.boundarySurfaces();
        // get the boundary surfaces
        Surface& firstFaceSurface  = bSurfacesFirst[firstFace]->surfaceRepresentation();
        Surface& secondFaceSurface  = bSurfacesSecond[secondFace]->surfaceRepresentation();
        // dynamic_cast to the right type
        std::unique_ptr<LayerMaterialProperties> lmps = layerMaterialProperties(firstFaceSurface);
        // LayerMaterialProperties will be cloned in MaterialLayer
 
        // set the layer to the two surfaces
        if (lmps){
            auto mLayer = std::make_shared<MaterialLayerNoOwnSurf>(&firstFaceSurface, std::move(lmps));
            ATH_MSG_VERBOSE( "Set MaterialLayer to the BoundarySurface of first volume." );
            firstFaceSurface.setMaterialLayer(mLayer);
            ATH_MSG_VERBOSE("Set MaterialLayer to the BoundarySurface of second volume.");
            secondFaceSurface.setMaterialLayer(mLayer);
        }
    }
}

glueVolumes()

void Trk::TrackingVolumeManipulator::glueVolumes ( Trk::TrackingVolume & firstVol, Trk::BoundarySurfaceFace firstFace, Trk::TrackingVolume & secondVol, Trk::BoundarySurfaceFace secondFace ) const

protectedinherited

protected method to glue two Volumes together input:

• first TrackingVolume that keeps boundary surface
• face of the BoundarySurface to be kept
• second volume that gets glued to the first volume
• face of the BoundarySurface to be shared

Definition at line 17 of file TrackingVolumeManipulator.cxx.

{
  // check if it is a cylinder volume
  const Trk::CylinderVolumeBounds* cylBounds =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(&(firstVol.volumeBounds()));
 
  if (firstFace == Trk::tubeOuterCover && secondFace == Trk::tubeInnerCover)
    return glueVolumes(secondVol, secondFace, firstVol, firstFace);
 
  // the second volume gets the face of the first volume assigned
  (secondVol.m_boundarySurfaces)[secondFace] =
    (firstVol.m_boundarySurfaces)[firstFace];
  // the face of the first volume has been an inner tube
  if (cylBounds && firstFace == Trk::tubeInnerCover &&
      secondFace == Trk::tubeOuterCover) {
    (secondVol.m_boundarySurfaces)[secondFace]->setInsideVolume(&secondVol);
  } else {
    (secondVol.m_boundarySurfaces)[secondFace]->setOutsideVolume(&secondVol);
  }
}

initialize()

StatusCode Trk::TrackingVolumeHelper::initialize ( )

override

AlgTool initialize method.

Definition at line 60 of file TrackingVolumeHelper.cxx.

                                            {
 
    ATH_MSG_DEBUG( "initialize() " );
    ATH_CHECK(m_layerArrayCreator.retrieve());
    ATH_CHECK(m_trackingVolumeArrayCreator.retrieve());
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

layerMaterialProperties()

std::unique_ptr< LayerMaterialProperties > Trk::TrackingVolumeHelper::layerMaterialProperties ( const Trk::Surface & sf ) const

private

< helper method to construct barrel material

Definition at line 704 of file TrackingVolumeHelper.cxx.

                                                                                      {
 
  std::unique_ptr<LayerMaterialProperties> layerMaterial{};
 
  if (boundarySurface.type() == SurfaceType::Cylinder){
        const CylinderBounds* cb = dynamic_cast<const CylinderBounds*>(&boundarySurface.bounds());
        if (!cb) throw std::logic_error("Not CylinderBounds");
        // --------------- material estimation ----------------------------------------------------------------
        // -- material with 1D binning
        double hz = cb->halflengthZ();
        double r  = cb->r();
        BinUtility layerBinUtilityZ(m_barrelLayerBinsZ, -hz, hz, open, binZ);
        if (m_barrelLayerBinsPhi==1){
            layerMaterial = std::make_unique<BinnedLayerMaterial>(layerBinUtilityZ);
        } else  { // -- material with 2D binning
            BinUtility layerBinUtilityRPhiZ(m_barrelLayerBinsPhi, -r*M_PI, r*M_PI, closed,binRPhi);
            layerBinUtilityRPhiZ += layerBinUtilityZ;
            layerMaterial = std::make_unique<BinnedLayerMaterial>(layerBinUtilityRPhiZ);
        }
        // --------------- material estimation ----------------------------------------------------------------
  }
  if (boundarySurface.type() == SurfaceType::Disc){
      // --------------- material estimation ----------------------------------------------------------------
      const DiscBounds* db = dynamic_cast<const DiscBounds*>(&boundarySurface.bounds());
      if (!db) throw std::logic_error("Not DiscBounds");
      double rMin = db->rMin();
      double rMax = db->rMax();
      BinUtility layerBinUtilityR(m_endcapLayerBinsR,rMin,rMax,open, binR);
      // -- material with 1D binning
      if (m_endcapLayerBinsPhi==1){
          layerMaterial =  std::make_unique<BinnedLayerMaterial>(layerBinUtilityR);
      } else { // -- material with 2D binning
          BinUtility layerBinUtilityPhi(m_endcapLayerBinsPhi,-M_PI,M_PI,closed,binPhi);
          layerBinUtilityR += layerBinUtilityPhi;
          layerMaterial = std::make_unique<BinnedLayerMaterial>(layerBinUtilityR);
      }
      // --------------- material estimation ----------------------------------------------------------------
  }
  // return what you have
  return layerMaterial;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setBoundarySurface()

void Trk::TrackingVolumeManipulator::setBoundarySurface ( Trk::TrackingVolume & tvol, std::shared_ptr< BoundarySurface< TrackingVolume > > bsurf, Trk::BoundarySurfaceFace face )

staticprotectedinherited

protected method to set the boundary surface of a tracking volume

Definition at line 43 of file TrackingVolumeManipulator.cxx.

{
  (tvol.m_boundarySurfaces)[face] = std::move(bsurf);
}

setInsideTrackingVolume()

void Trk::TrackingVolumeHelper::setInsideTrackingVolume ( TrackingVolume & tvol, BoundarySurfaceFace face, TrackingVolume * insidevol ) const

overridevirtual

protected method to set inside Volume of a BoundarySurface: input:

Simply forward to base class method to enhance friendship relation.

• the volume that holds the BoundarySurface
• the face type of the boundary to be set
• the volume to be set as inside volume

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 749 of file TrackingVolumeHelper.cxx.

                                                                                    {
    TrackingVolumeManipulator::setInsideVolume( tvol, face, insidevol );
}

setInsideTrackingVolumeArray()

void Trk::TrackingVolumeHelper::setInsideTrackingVolumeArray ( TrackingVolume & tvol, BoundarySurfaceFace face, std::shared_ptr< BinnedArray< TrackingVolume > > insidevolarray ) const

overridevirtual

protected method to set inside VolumeArray of a BoundarySurface: input:

Simply forward to base class method to enhance friendship relation.

• the volume that holds the BoundarySurface
• the face type of the boundary to be set
• the volume array to be set as inside volume array

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 757 of file TrackingVolumeHelper.cxx.

                                                                                                                          {
    TrackingVolumeManipulator::setInsideVolumeArray(tvol,face,insidevolarray);
}

setInsideVolume()

void Trk::TrackingVolumeManipulator::setInsideVolume ( Trk::TrackingVolume & tvol, Trk::BoundarySurfaceFace face, Trk::TrackingVolume * insidevol )

staticprotectedinherited

protected method to set inside Volume of a BoundarySurface: input:

• the volume that holdes the BoundarySurface
• the face type of the boundary to be set
• the volume to be set as inside volume

Definition at line 52 of file TrackingVolumeManipulator.cxx.

{
 
  (tvol.m_boundarySurfaces)[face]->setInsideVolume(insidevol);
}

setInsideVolumeArray()

void Trk::TrackingVolumeManipulator::setInsideVolumeArray ( Trk::TrackingVolume & tvol, Trk::BoundarySurfaceFace face, const std::shared_ptr< BinnedArray< TrackingVolume > > & insidevolarray )

staticprotectedinherited

protected method to set inside VolumeArray of a BoundarySurface: input:

• ithe volume that holdes the BoundarySurface
• the face type of the boundary to be set
• the volume array to be set as inside volume array

Definition at line 61 of file TrackingVolumeManipulator.cxx.

{
  (tvol.m_boundarySurfaces)[face]->setInsideVolumeArray(insidevolarray);
}

setOutsideTrackingVolume()

void Trk::TrackingVolumeHelper::setOutsideTrackingVolume ( TrackingVolume & tvol, BoundarySurfaceFace face, TrackingVolume * outsidevol ) const

overridevirtual

protected method to set outside Volume of a BoundarySurface: input:

Simply forward to base class method to enhance friendship relation.

• the volume that holds the BoundarySurface
• the face type of the boundary to be set
• the volume to be set as outside volume

— Necessary as friendship cannot be inherited: your father's friend isn't necessary yours —

Implements Trk::ITrackingVolumeHelper.

Definition at line 765 of file TrackingVolumeHelper.cxx.

                                                                                      {
    ATH_MSG_VERBOSE( "     -> Glue '" << outsidevol->volumeName() << "' at face " << face << " to '" << tvol.volumeName() << "'.");
    TrackingVolumeManipulator::setOutsideVolume( tvol, face, outsidevol );
}

setOutsideTrackingVolumeArray()

void Trk::TrackingVolumeHelper::setOutsideTrackingVolumeArray ( TrackingVolume & tvol, BoundarySurfaceFace face, std::shared_ptr< BinnedArray< TrackingVolume > > outsidevolarray ) const

overridevirtual

protected method to set outside VolumeArray of a BoundarySurface: input:

Simply forward to base class method to enhance friendship relation.

• the volume that holds the BoundarySurface
• the face type of the boundary to be set
• the volume array to be set as outside volume array

Implements Trk::ITrackingVolumeHelper.

Definition at line 774 of file TrackingVolumeHelper.cxx.

                                                                                                                            {
    unsigned int numVols = outsidevolarray.get()->arrayObjects().size() ;
    ATH_MSG_VERBOSE( "     -> Glue " << numVols << " volumes at face " << face << " to '" << tvol.volumeName() );
    TrackingVolumeManipulator::setOutsideVolumeArray( tvol, face, outsidevolarray );
}

setOutsideVolume()

void Trk::TrackingVolumeManipulator::setOutsideVolume ( Trk::TrackingVolume & tvol, Trk::BoundarySurfaceFace face, Trk::TrackingVolume * outsidevol )

staticprotectedinherited

protected method to set outside Volume of a BoundarySurface: input:

• the volume that holdes the BoundarySurface
• the face type of the boundary to be set
• the volume to be set as outside volume

Definition at line 71 of file TrackingVolumeManipulator.cxx.

{
  (tvol.m_boundarySurfaces)[face]->setOutsideVolume(outsidevol);
}

setOutsideVolumeArray()

void Trk::TrackingVolumeManipulator::setOutsideVolumeArray ( Trk::TrackingVolume & tvol, Trk::BoundarySurfaceFace face, const std::shared_ptr< BinnedArray< TrackingVolume > > & outsidevolarray )

staticprotectedinherited

protected method to set outside VolumeArray of a BoundarySurface: input:

• the volume that holdes the BoundarySurface
• the face type of the boundary to be set
• the volume array to be set as outside volume array

Definition at line 80 of file TrackingVolumeManipulator.cxx.

{
  (tvol.m_boundarySurfaces)[face]->setOutsideVolumeArray(outsidevolarray);
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_barrelLayerBinsPhi

Gaudi::Property<int> Trk::TrackingVolumeHelper::m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}

private

material bins in Phi

Definition at line 232 of file TrackingVolumeHelper.h.

{this, "BarrelLayerBinsPhi", 1}; 

m_barrelLayerBinsZ

Gaudi::Property<int> Trk::TrackingVolumeHelper::m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 1}

private

material bins in Z

Definition at line 231 of file TrackingVolumeHelper.h.

{this, "BarrelLayerBinsZ", 1};   

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_endcapLayerBinsPhi

Gaudi::Property<int> Trk::TrackingVolumeHelper::m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}

private

material bins in Phi

Definition at line 234 of file TrackingVolumeHelper.h.

{this, "EndcapLayerBinsPhi", 1}; 

m_endcapLayerBinsR

Gaudi::Property<int> Trk::TrackingVolumeHelper::m_endcapLayerBinsR {this, "EndcapLayerBinsR", 1}

private

material bins in R

Definition at line 233 of file TrackingVolumeHelper.h.

{this, "EndcapLayerBinsR", 1};   

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_layerArrayCreator

PublicToolHandle<ILayerArrayCreator> Trk::TrackingVolumeHelper::m_layerArrayCreator {this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}

private

A Tool for coherent LayerArray creation.

Definition at line 226 of file TrackingVolumeHelper.h.

{this, "LayerArrayCreator", "Trk::LayerArrayCreator/LayerArrayCreator"}; 

m_trackingVolumeArrayCreator

ToolHandle<ITrackingVolumeArrayCreator> Trk::TrackingVolumeHelper::m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}

private

Helper Tool to create TrackingVolume.

Arrays

Definition at line 228 of file TrackingVolumeHelper.h.

{this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}; 

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_layerThickness

double Trk::TrackingVolumeHelper::s_layerThickness

staticconstexprprivate

Initial value:

=
    1. * Gaudi::Units::mm

standard layer thickness

Definition at line 236 of file TrackingVolumeHelper.h.

---

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

• TrackingVolumeHelper.h
• TrackingVolumeHelper.cxx