InDet::StagedTrackingGeometryBuilderImpl Class Reference

#include <StagedTrackingGeometryBuilderImpl.h>

Inheritance diagram for InDet::StagedTrackingGeometryBuilderImpl:

Collaboration diagram for InDet::StagedTrackingGeometryBuilderImpl:

Public Member Functions
	StagedTrackingGeometryBuilderImpl (const std::string &, const std::string &, const IInterface *)
	Constructor. More...
virtual	~StagedTrackingGeometryBuilderImpl ()=default
	Destructor. More...
virtual StatusCode	initialize () override
	AlgTool initialize method. More...
virtual StatusCode	finalize () override
	AlgTool finalize method. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
std::unique_ptr< Trk::TrackingGeometry >	trackingGeometryImpl (std::vector< InDet::LayerSetup > &layerSetups, double maximumLayerExtendZ, double maximumLayerRadius, double envelopeVolumeHalfZ, double envelopeVolumeRadius) const
void	estimateLayerDimensions (const std::vector< Trk::Layer * > &layers, double &rMin, double &rMax, double &zMin, double &zMax) const
	Private helper method to estimate the layer dimensions. More...
Trk::TrackingVolume *	createTrackingVolume (const std::vector< Trk::Layer * > &layers, double innerRadius, double &outerRadius, double zMin, double zMax, const std::string &volumeName, Trk::BinningType btype, bool doAdjustOuterRadius=true) const
	Private helper method, creates a TrackingVolume - and checks if configured - for Ring Layout. More...
Trk::TrackingVolume *	packVolumeTriple (const std::vector< Trk::TrackingVolume * > &negVolumes, const std::vector< Trk::TrackingVolume * > &centralVolumes, const std::vector< Trk::TrackingVolume * > &posVolumes, const std::string &baseName="UndefinedVolume") const
	Private helper method, creates and packs a triple containing of NegEndcap-Barrel-PosEndcap volumes. More...
LayerSetup	estimateLayerSetup (const std::string &idName, size_t ils, const std::vector< Trk::Layer * > &negLayers, const std::vector< Trk::Layer * > &centralLayers, const std::vector< Trk::Layer * > &posLayers, double maxR, double maxZ) const
	Private helper method, estimates the overal dimensions. More...
bool	setupFitsCache (LayerSetup &layerSetup, std::vector< InDet::LayerSetup > &layerSetupCache) const
	Private helper method to check if a sector is compatible with the cache. More...
Trk::TrackingVolume *	createFlushVolume (std::vector< InDet::LayerSetup > &layerSetupCache, double innerRadius, double &outerRadius, double extendZ) const
	Private helper method to flush the cache into the id volumes - return volume is the one to be provided. More...
Trk::TrackingVolume *	packVolumeTriple (LayerSetup &layerSetup, double rMin, double &rMax, double zMin, double zPosCentral) const
	Private helper method, creates and packs a triple containing of NegEndcap-Barrel-PosEndcap layers. More...
bool	ringLayout (const std::vector< Trk::Layer * > &layers, std::vector< double > &rmins, std::vector< double > &rmaxs) const
	Private helper method for detection of Ring layout. More...
void	checkForInsert (std::vector< double > &radii, double radius) const
	helper method needed for the Ring layout More...
void	checkForInsert (double rmin, double rmax, std::vector< std::pair< double, double >> &radii) const
std::vector< Trk::Layer * >	checkZoverlap (std::vector< Trk::Layer * > &lays) const
	Private helper method for merging of rings with z-overlap. More...
Trk::Layer *	mergeDiscLayers (std::vector< Trk::Layer * > &dlays) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...
void	glueVolumes (TrackingVolume &firstVol, BoundarySurfaceFace firstFace, TrackingVolume &secondVol, BoundarySurfaceFace secondFace) const
	protected method to glue two Volumes together input: More...

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

Protected Attributes
CxxUtils::CachedUniquePtrT< Trk::Material >	m_materialProperties
	overal material properties of the ID More...
PublicToolHandle< Trk::ITrackingVolumeCreator >	m_trackingVolumeCreator
	< Helper Tool to create TrackingVolumes More...
PublicToolHandle< Trk::ILayerArrayCreator >	m_layerArrayCreator
	Helper Tool to create BinnedArrays. More...
IntegerArrayProperty	m_layerBinningTypeCenter
	binning type for the provided layers More...
IntegerArrayProperty	m_layerBinningTypeEndcap
	binning type for the provided layers More...
IntegerArrayProperty	m_colorCodesConfig
	Color codes. More...
ServiceHandle< IEnvelopeDefSvc >	m_enclosingEnvelopeSvc
	the service to provide the ID envelope size More...
DoubleArrayProperty	m_enclosingCylinderRadius
	the cylinder layer inside the enclosing volume More...
DoubleArrayProperty	m_enclosingDiscPositionZ
	the disc position inside the enclosing volume More...
DoubleProperty	m_layerEnvelopeCover
	innermost - outermost More...
BooleanProperty	m_buildBoundaryLayers
	create boundary layers More...
BooleanProperty	m_replaceJointBoundaries
	run with replacement of all joint boundaries More...
BooleanProperty	m_indexStaticLayers
	forces robust indexing for layers More...
BooleanProperty	m_checkForRingLayout
	this is to check for the endcap ring layout More...
DoubleProperty	m_ringTolerance
	the ring tolerance More...
StringProperty	m_namespace
	identificaton namespace More...
StringProperty	m_exitVolume
	the final ID container More...
BooleanProperty	m_removeHGTD {this, "RemoveHGTD", false}
FloatProperty	m_zMinHGTD {this, "ZminHGTD", 3420.f}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

New Geometry builder that adapts to different layer setups

Only a few parameters are not automated:

• m_outwardsFraction: this defines how much you orient yourself on the next bigger layer if you wrap an outer volume around an inner 0.5 would lead to a boundary fully in bewteen
  1. at the outer boundary, 0. at the inner boundary

Author

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

Definition at line 121 of file StagedTrackingGeometryBuilderImpl.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

StagedTrackingGeometryBuilderImpl()

InDet::StagedTrackingGeometryBuilderImpl::StagedTrackingGeometryBuilderImpl	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Constructor.

Definition at line 29 of file StagedTrackingGeometryBuilderImpl.cxx.

                                                                                                                                     :
  AthAlgTool(t,n,p),
  Trk::TrackingVolumeManipulator()
{
}

~StagedTrackingGeometryBuilderImpl()

virtual InDet::StagedTrackingGeometryBuilderImpl::~StagedTrackingGeometryBuilderImpl ( )

virtualdefault

Destructor.

Member Function Documentation

checkForInsert() [1/2]

void InDet::StagedTrackingGeometryBuilderImpl::checkForInsert ( double  rmin, double  rmax, std::vector< std::pair< double, double >> &  radii  ) const

inlineprotected

Definition at line 307 of file StagedTrackingGeometryBuilderImpl.h.

                                                                                                                                         {
 
    // range into non-overlapping layers
 
    if (!radii.size()) radii.push_back(std::pair<double,double>(rmin,rmax));
 
    unsigned int ir=0;
    while ( ir != radii.size() && rmin > radii[ir].second ) ir++;
 
    if (ir==radii.size()) radii.push_back(std::pair<double,double>(rmin,rmax));
    // insert ?
    else if (rmax<radii[ir].first) radii.insert(radii.begin()+ir,std::pair<double,double>(rmin,rmax));
    // overlaps
    else {
      // resolve low edge
      if (rmin<radii[ir].first) radii[ir].first=rmin;
      // resolve upper edge
      unsigned int imerge = ir;
      while (imerge<radii.size()-1 && rmax>radii[imerge+1].first) imerge++;
      radii[ir].second = rmax > radii[imerge].second ? rmax : radii[imerge].second;
      if (imerge>ir) radii.erase(radii.begin()+ir+1,radii.begin()+imerge);
    }
  }

checkForInsert() [2/2]

void InDet::StagedTrackingGeometryBuilderImpl::checkForInsert ( std::vector< double > &  radii, double  radius  ) const

inlineprotected

helper method needed for the Ring layout

Definition at line 293 of file StagedTrackingGeometryBuilderImpl.h.

                                                                                                             {
      bool exists = false;
      // loop and check
      for (auto& checkr : radii) {
          if ( (checkr-radius)*(checkr-radius) < m_ringTolerance*m_ringTolerance ){
              exists = true; break;
          }
      }
      // insert
      if (!exists) radii.push_back(radius);
      // re-sort
      std::sort(radii.begin(),radii.end());
  }

checkZoverlap()

std::vector< Trk::Layer * > InDet::StagedTrackingGeometryBuilderImpl::checkZoverlap ( std::vector< Trk::Layer * > &  lays ) const

protected

Private helper method for merging of rings with z-overlap.

Definition at line 743 of file StagedTrackingGeometryBuilderImpl.cxx.

{
  // look for layers to merge if they overlap in z
 
  // caching the layers with locations in z
  std::map < float , std::vector<Trk::Layer*> > locationAndLayers;
 
  // loop on the layers and save the location:
  // if one layer location is compatible with
  // another one (considering the layer thickness)
  // then the two layers have to be merged
  for (auto *lay : lays) {
    float zpos= lay->surfaceRepresentation().center().z();
    float thick = 0.5*lay->thickness();
 
    bool foundZoverlap = false;
    for (auto& singlePosLayer : locationAndLayers) {
      if (abs(zpos - singlePosLayer.first) < thick) {
        singlePosLayer.second.push_back(lay);
        foundZoverlap = true;
        break;
      }
    }
 
    // if no overlap is found, a new location (with corresponding layer)
    // has to be added to the map
    if (not foundZoverlap) {
      locationAndLayers[zpos] = std::vector<Trk::Layer*>();
      locationAndLayers[zpos].push_back(lay);
    }
  }
 
  // If the number of final layers decreases,
  // merging is detected and discs need to be merged.
  // The new merged layers are returned instead of the initial ones.
  if (lays.size()>locationAndLayers.size()) {
    std::vector<Trk::Layer*> mergedDiscLayers;
    for (auto& singlePosLayer : locationAndLayers) {
      Trk::Layer* nd = mergeDiscLayers(singlePosLayer.second);
      if (nd) mergedDiscLayers.push_back(nd);
      else {
        ATH_MSG_WARNING("radial merge of rings failed, return the input layer set");
        return lays;
      }
    }
    return mergedDiscLayers;
  }
 
  return lays;
 
}

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

createFlushVolume()

Trk::TrackingVolume * InDet::StagedTrackingGeometryBuilderImpl::createFlushVolume ( std::vector< InDet::LayerSetup > &  layerSetupCache, double  innerRadius, double &  outerRadius, double  extendZ  ) const

protected

Private helper method to flush the cache into the id volumes - return volume is the one to be provided.

Definition at line 649 of file StagedTrackingGeometryBuilderImpl.cxx.

{
  // the return volume
  Trk::TrackingVolume* flushVolume = nullptr;
  //
  if (layerSetupCache.size() == 1 ){
    ATH_MSG_VERBOSE("       -> single sector setup - synchronising from inner (" << innerRadius << ") to outer (" << outerRadius << ") radius.");
    ATH_MSG_VERBOSE("       -> setup identification : " << layerSetupCache[0].identification );
    // create the new tracking volume - either as a triple or as a single
    flushVolume = layerSetupCache[0].buildEndcap ?
      packVolumeTriple(layerSetupCache[0],
                       innerRadius, outerRadius,
                       extendZ,layerSetupCache[0].zSector) :
      m_trackingVolumeCreator->createTrackingVolume(layerSetupCache[0].centralLayers,
                                                    *m_materialProperties,
                                                    innerRadius,outerRadius,
                                                    -extendZ,extendZ,
                                                    layerSetupCache[0].identification,
                                                    (Trk::BinningType)layerSetupCache[0].binningCenter);
 
  } else {
    ATH_MSG_VERBOSE("       -> setup with " << layerSetupCache.size() << " entries - synchronising from inner (" << innerRadius << ") to outer (" << outerRadius << ") radius.");
    // prepare the volume vectors & name identification
    std::vector<Trk::TrackingVolume*> negVolumes;
    std::vector<Trk::TrackingVolume*> centralVolumes;
    std::vector<Trk::TrackingVolume*> posVolumes;
    std::string combinedName;
    for (size_t ilS = 0; ilS < layerSetupCache.size(); ++ilS){
      // take the given inner radius for the first one - median otherwise
      double irE = ilS ? 0.5*(layerSetupCache[ilS].minRadiusEndcap+layerSetupCache[ilS-1].maxRadiusEndcap) : innerRadius;
      double irC = ilS ? 0.5*(layerSetupCache[ilS].minRadiusCenter+layerSetupCache[ilS-1].maxRadiusCenter) : innerRadius;
      // take the given outer radius for the last one - median otherwise
      double orE = ((ilS+1)==layerSetupCache.size()) ? outerRadius : 0.5*(layerSetupCache[ilS+1].minRadiusEndcap+layerSetupCache[ilS].maxRadiusEndcap);
      double orC = ((ilS+1)==layerSetupCache.size()) ? outerRadius : 0.5*(layerSetupCache[ilS+1].minRadiusCenter+layerSetupCache[ilS].maxRadiusCenter);
      // Adjust last volumes in R to the same maximal radial extends!
      if(ilS==layerSetupCache.size()-1) {
        ATH_MSG_VERBOSE("Processing last volume");
        ATH_MSG_VERBOSE("  --> adjust volumes to same extends: orE=" << orE << " orC=" << orC);
        if(orE>orC) orC=orE; else orE=orC;
      }
      // create the three volumes
      Trk::TrackingVolume* nVolume = createTrackingVolume(
                                                          layerSetupCache[ilS].negativeLayers,
                                                          irE,
                                                          orE,
                                                          -extendZ,
                                                          -layerSetupCache[ilS].zSector,
                                                          layerSetupCache[ilS].identification + "::NegativeEndcap",
                                                          (Trk::BinningType)layerSetupCache[ilS].binningEndcap,
                                                          false);
      Trk::TrackingVolume* cVolume =
        m_trackingVolumeCreator->createTrackingVolume(
                                                      layerSetupCache[ilS].centralLayers,
                                                      *m_materialProperties,
                                                      irC,
                                                      orC,
                                                      -layerSetupCache[ilS].zSector,
                                                      layerSetupCache[ilS].zSector,
                                                      layerSetupCache[ilS].identification + "::Barrel",
                                                      (Trk::BinningType)layerSetupCache[ilS].binningCenter);
      Trk::TrackingVolume* pVolume = createTrackingVolume(
                                                          layerSetupCache[ilS].positiveLayers,
                                                          irE,
                                                          orE,
                                                          layerSetupCache[ilS].zSector,
                                                          extendZ,
                                                          layerSetupCache[ilS].identification + "::PositiveEndcap",
                                                          (Trk::BinningType)layerSetupCache[ilS].binningEndcap,
                                                          false);
      // register the right color code
      nVolume->registerColorCode(layerSetupCache[ilS].colorCode);
      cVolume->registerColorCode(layerSetupCache[ilS].colorCode);
      pVolume->registerColorCode(layerSetupCache[ilS].colorCode);
      // push them into the volume containers
      negVolumes.push_back(nVolume);
      centralVolumes.push_back(cVolume);
      posVolumes.push_back(pVolume);
      // combined name
      combinedName += "_"+layerSetupCache[ilS].identification;
    }
    ATH_MSG_VERBOSE("       -> setup identification : " << combinedName );
    flushVolume  = packVolumeTriple(negVolumes,centralVolumes,posVolumes,combinedName);
  }
  // clear the cache
  layerSetupCache.clear();
  // return the volume
  return flushVolume;
 
}

createTrackingVolume()

Trk::TrackingVolume * InDet::StagedTrackingGeometryBuilderImpl::createTrackingVolume ( const std::vector< Trk::Layer * > &  layers, double  innerRadius, double &  outerRadius, double  zMin, double  zMax, const std::string &  volumeName, Trk::BinningType  btype, bool  doAdjustOuterRadius = true  ) const

protected

Private helper method, creates a TrackingVolume - and checks if configured - for Ring Layout.

• in case a ring layout is given, it creates the corresponding sub-volumes and updates the radius

Definition at line 285 of file StagedTrackingGeometryBuilderImpl.cxx.

{
 
    // first loop - this is for diagnostics for the radii
    std::vector<double> ringRmins;
    std::vector<double> ringRmaxa;
    if (m_checkForRingLayout && ringLayout(layers,ringRmins, ringRmaxa)){
        ATH_MSG_INFO("Ring layout is present for volume '" << volumeName << "' dealing with it.");
        // create the vector for the sub volumes
        std::vector<Trk::TrackingVolume* > ringVolumes;
        std::vector<Trk::TrackingVolume* > const_ringVolumes;
 
        // now sort the necessary layers --- for the sub volumes
        std::vector< std::vector<Trk::Layer*> > groupedDiscs(ringRmins.size(), std::vector<Trk::Layer*>() );
        // second loop over the rings
        for (auto *ring : layers){
            // Surface
            const Trk::Surface&     ringSurface = ring->surfaceRepresentation();
            const Trk::DiscBounds*  ringBounds  = dynamic_cast<const Trk::DiscBounds*>(&(ringSurface.bounds()));
            if (ringBounds){
                // get the main parameters
                double rMax         = ringBounds->rMax();
                size_t rPos         = 0;
                // fill into the right group
                for (auto& rm : ringRmaxa){
                    if (rMax < rm+m_ringTolerance) break;
                    ++rPos;
                }
                // fill it it
                Trk::DiscLayer* dring = dynamic_cast<Trk::DiscLayer*>(ring);
                if (dring) groupedDiscs[rPos].push_back(dring);
            }
        }
      // layer merging may be needed
      std::vector< std::vector<Trk::Layer*> > mergedLayers;
      std::vector< float > mergedRmax;
      std::vector< std::vector< int > > merge;
      std::vector<int> laySet(1,0); merge.push_back(laySet);
      double rCurr = ringRmaxa[0];
      mergedRmax.push_back(rCurr);
      for (int idset = 1; idset < int(groupedDiscs.size()); idset++){
        if (ringRmins[idset]<=rCurr + m_ringTolerance) {
          merge.back().push_back(idset);
          if (ringRmaxa[idset]>mergedRmax.back()) mergedRmax.back()=ringRmaxa[idset];
        } else {
          merge.emplace_back(1,idset);
          mergedRmax.push_back(ringRmaxa[idset]);
        }
        rCurr = ringRmaxa[idset];
      }
      for ( const auto& layset : merge ) {
        std::vector<Trk::Layer*> ringSet;
        for ( const auto& lay : layset ) {
          for ( auto *ring : groupedDiscs[lay]) {
            float zPos = ring->surfaceRepresentation().center().z();
            if (ringSet.empty() || zPos>ringSet.back()->surfaceRepresentation().center().z()) ringSet.push_back(ring);
            else {
              std::vector<Trk::Layer*>::iterator lit = ringSet.begin();
              while (lit!=ringSet.end() && zPos>(*lit)->surfaceRepresentation().center().z()) ++lit;
              ringSet.insert(lit,ring);
            }
          }
        }
        // rings ordered in z : resolve overlap
        mergedLayers.push_back(checkZoverlap(ringSet));
      }
      // we are now grouped in cylinder rings per volume
      for (int idset = 0; idset < int(mergedLayers.size()); idset++){
        // always keep the boundaries in mind for the radial extend
        double crmin = idset ? mergedRmax[idset-1]+m_layerEnvelopeCover : innerRadius;
        double crmax = mergedRmax[idset]+m_layerEnvelopeCover;
        if(idset==int(mergedLayers.size())-1 && !doAdjustOuterRadius) crmax = outerRadius;
        // now create the sub volume
        std::string ringVolumeName = volumeName+"Ring"+std::to_string(idset);
        Trk::TrackingVolume* ringVolume =
          m_trackingVolumeCreator->createTrackingVolume(mergedLayers[idset],
                                                        *m_materialProperties,
                                                        crmin,
                                                        crmax,
                                                        zMin,
                                                        zMax,
                                                        ringVolumeName,
                                                        binningType);
        // push back into the vectors
        ringVolumes.push_back(ringVolume);
        const_ringVolumes.push_back(ringVolume);
      }
      // set the outer radius
      if(doAdjustOuterRadius) outerRadius = ringRmaxa[ringRmaxa.size()-1]+m_layerEnvelopeCover;
      //
      ATH_MSG_INFO("      -> adjusting the outer radius to the last ring at " << outerRadius );
      ATH_MSG_INFO("      -> created " << ringVolumes.size() << " ring volumes for Volume '" << volumeName << "'.");
      // create the tiple container
      if (ringVolumes.size()==1)
        return ringVolumes.at(0);
      else
        return m_trackingVolumeCreator->createContainerTrackingVolume(const_ringVolumes,
                                                                      *m_materialProperties,
                                                                      volumeName,
                                                                      m_buildBoundaryLayers,
                                                                      m_replaceJointBoundaries);
    } else
        return m_trackingVolumeCreator->createTrackingVolume(layers,
                                                             *m_materialProperties,
                                                             innerRadius,outerRadius,
                                                             zMin,zMax,
                                                             volumeName,
                                                             binningType);
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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; }

estimateLayerDimensions()

void InDet::StagedTrackingGeometryBuilderImpl::estimateLayerDimensions ( const std::vector< Trk::Layer * > &  layers, double &  rMin, double &  rMax, double &  zMin, double &  zMax  ) const

protected

Private helper method to estimate the layer dimensions.

Definition at line 195 of file StagedTrackingGeometryBuilderImpl.cxx.

{
    // parse through the layers and estimate
      for (auto *const layer : layers){
          // the thickness of the layer needs to be taken into account
          double thickness = layer->thickness();
          // get the center
          const Amg::Vector3D& center = layer->surfaceRepresentation().center();
          // check if it is a cylinder layer
          const Trk::CylinderLayer* cLayer = dynamic_cast<const Trk::CylinderLayer*>(layer);
          if (cLayer){
              // now we have access to all the information
              double rMinC  = cLayer->surfaceRepresentation().bounds().r()-0.5*thickness-m_layerEnvelopeCover;
              double rMaxC  = cLayer->surfaceRepresentation().bounds().r()+0.5*thickness+m_layerEnvelopeCover;
              double hZ = cLayer->surfaceRepresentation().bounds().halflengthZ();
              takeSmaller(rMin,rMinC);
              takeBigger(rMax,rMaxC);
              takeSmaller(zMin,center.z()-hZ);
              takeBigger(zMax,center.z()+hZ);
          }
          // proceed further if it is a Disc layer
          const Trk::DiscBounds* dBounds = dynamic_cast<const Trk::DiscBounds*>(&(layer->surfaceRepresentation().bounds()));
          if (dBounds){
              // now we have access to all the information
              double rMinD =dBounds->rMin();
              double rMaxD =dBounds->rMax();
              double zMinD =  center.z()-0.5*thickness-m_layerEnvelopeCover;
              double zMaxD =  center.z()+0.5*thickness+m_layerEnvelopeCover;
              takeSmaller(rMin,rMinD);
              takeBigger(rMax,rMaxD);
              takeSmaller(zMin,zMinD);
              takeBigger(zMax,zMaxD);
          }
      }
}

estimateLayerSetup()

InDet::LayerSetup InDet::StagedTrackingGeometryBuilderImpl::estimateLayerSetup ( const std::string &  idName, size_t  ils, const std::vector< Trk::Layer * > &  negLayers, const std::vector< Trk::Layer * > &  centralLayers, const std::vector< Trk::Layer * > &  posLayers, double  maxR, double  maxZ  ) const

protected

Private helper method, estimates the overal dimensions.

Definition at line 541 of file StagedTrackingGeometryBuilderImpl.cxx.

{
  // prepare the dimensions
  double cenMinR  = 10e10;
  double cenMaxR  = 0.;
  double cenMinZ  = 10e10;
  double cenMaxZ  = 0.;
  double posMinR  = 10e10;
  double posMaxR  = 0.;
  double posMinZ  = 10e10;
  double posMaxZ  = 0.;
  // parse through the central layers first
  estimateLayerDimensions(cenLayers, cenMinR, cenMaxR, cenMinZ, cenMaxZ);
  // parse throught the positive layers - we assume a symmetric setup
  estimateLayerDimensions(posLayers, posMinR, posMaxR, posMinZ, posMaxZ);
  // reset to maxZ and and maxR if overs
  if (posMaxZ > maxZ) {
    ATH_MSG_WARNING("Estimated z extended of central sector bigger than maximal z extened. Resetting - may lose layers though.");
    cenMaxZ = maxZ;
  } else if (posMaxZ > maxZ) {
    ATH_MSG_WARNING("Estimated z extended of endcap sector bigger than maximal z extened. Resetting - may lose layers though.");
    posMaxZ = maxZ;
  }
  // reset the radial wones.
  if (cenMaxR > maxR) {
    ATH_MSG_WARNING("Estimated r extended of central sector bigger than maximal r extened. Resetting - may lose layers though.");
    cenMaxR = maxR;
  }
  if (posMaxR > maxR) {
    ATH_MSG_WARNING("Estimated r extended of endcap sector bigger than maximal r extened. Resetting - may lose layers though.");
    posMaxR = maxR;
  }
  // create the layer setup class
  return InDet::LayerSetup(idName,
                               m_colorCodesConfig[ilS],
                               negLayers,
                               cenLayers,
                               posLayers,
                               cenMinR,
                               cenMaxR,
                               cenMaxZ,
                               m_layerBinningTypeCenter[ilS],
                               !posLayers.empty(),
                               posMinR,
                               posMaxR,
                               posMinZ,
                               posMaxZ,
                               m_layerBinningTypeEndcap[ilS]);
}

evtStore() [1/2]

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

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 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

finalize()

StatusCode InDet::StagedTrackingGeometryBuilderImpl::finalize ( )

overridevirtual

AlgTool finalize method.

Definition at line 62 of file StagedTrackingGeometryBuilderImpl.cxx.

{
    ATH_MSG_INFO( "finalize() successful" );
    return StatusCode::SUCCESS;
}

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 InDet::StagedTrackingGeometryBuilderImpl::initialize ( )

overridevirtual

AlgTool initialize method.

Definition at line 38 of file StagedTrackingGeometryBuilderImpl.cxx.

{
 
  // retrieve envelope definition service --------------------------------------------------
  ATH_CHECK(m_enclosingEnvelopeSvc.retrieve());
 
  // Retrieve the tracking volume creator  -------------------------------------------------
  ATH_CHECK(m_trackingVolumeCreator.retrieve());
  ATH_MSG_DEBUG( "Retrieved tool " << m_trackingVolumeCreator );
 
  // Retrieve the layer array creator  ----------------------------------------------------
  ATH_CHECK(m_layerArrayCreator.retrieve());
  ATH_MSG_INFO( "Retrieved tool " << m_layerArrayCreator );
 
  // Dummy MaterialProerties
  m_materialProperties.set(std::make_unique<Trk::Material>());
 
  ATH_MSG_INFO( "initialize() succesful" );
 
  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.

mergeDiscLayers()

Trk::Layer * InDet::StagedTrackingGeometryBuilderImpl::mergeDiscLayers ( std::vector< Trk::Layer * > &  dlays ) const

protected

Definition at line 795 of file StagedTrackingGeometryBuilderImpl.cxx.

                                                                                                         {
  // if a single layer is input, no need for merging.
  // Returning the layer
  if (inputDiscs.size()==1)
    return inputDiscs.at(0);
 
  // on the input, disc layers overlapping in thickness : merge to a new DiscLayer
  std::pair<float,float> zb(1.e5,-1.e5);
  // order discs in radius
  std::vector< std::pair<float,float> > rbounds;
  std::vector<size_t> discOrder;
  size_t id=0;
  for ( const auto *  lay : inputDiscs ) {
    zb.first = fmin( zb.first, lay->surfaceRepresentation().center().z()-0.5*lay->thickness());
    zb.second = fmax( zb.second, lay->surfaceRepresentation().center().z()+0.5*lay->thickness());
    const Trk::DiscBounds* db = dynamic_cast<const Trk::DiscBounds*>(&(lay->surfaceRepresentation().bounds()));
    if (!db) {
      ATH_MSG_WARNING("attempt to merge non-disc layers, bailing out");
      return nullptr;
    }
    float r = db->rMin();
    if (rbounds.empty() ||  r>rbounds.back().first) {
      rbounds.emplace_back(r,db->rMax());
      discOrder.push_back(id);
    } else {
      int ir=rbounds.size()-1;
      while (ir>=0) {
        if ( r>rbounds[ir].first ) break;
        ir--;
      }
      auto rboundsInsertionPt(rbounds.begin());
      std::advance(rboundsInsertionPt, ir+1);
      rbounds.insert(rboundsInsertionPt,std::pair<float,float> (r,db->rMax()));
      auto discOrderInsertionPt(discOrder.begin());
      std::advance(discOrderInsertionPt, ir+1);
      discOrder.insert(discOrderInsertionPt,id);
    }
    id++;
  }
 
  std::vector<float> rsteps;
  std::vector<Trk::Surface*> surfs;
  std::vector<Trk::BinUtility*>* binUtils=new std::vector<Trk::BinUtility*>();
  rsteps.push_back(rbounds[0].first);
  for (unsigned int id=0; id<discOrder.size(); id++) {
    unsigned int index=discOrder[id];
    Trk::SurfaceArray* surfArray = inputDiscs[index]->surfaceArray();
    if (surfArray) {
      if (surfArray->binUtility()->binningValue()!=Trk::binPhi) {
        ATH_MSG_WARNING("attempt to merge 2D disc arrays, bailing out");
        return nullptr;
      }
      binUtils->push_back(surfArray->binUtility()->clone());
      if (id+1<discOrder.size()) rsteps.push_back( 0.5*(rbounds[id].second+rbounds[id+1].first));
      Trk::BinnedArraySpan<Trk::Surface * const> ringSurf =surfArray->arrayObjects();
      surfs.insert(surfs.end(),ringSurf.begin(),ringSurf.end());
 
    }
  }
  rsteps.push_back(rbounds.back().second);
 
  std::vector< std::pair< Trk::SharedObject<Trk::Surface>, Amg::Vector3D >  > surfaces;
  for ( auto *  sf : surfs ) {
    Trk::SharedObject<Trk::Surface> sharedSurface(sf,Trk::do_not_delete<Trk::Surface>);
    std::pair< Trk::SharedObject<Trk::Surface>, Amg::Vector3D >  surfaceOrder(sharedSurface, sf->center());
    surfaces.push_back(surfaceOrder);
  }
 
  // create merged binned array
  // a two-dimensional BinnedArray is needed ; takes possession of binUtils and
  // will delete it on destruction.
  auto mergeBA = std::make_unique<Trk::BinnedArray1D1D<Trk::Surface>>(
      surfaces, new Trk::BinUtility(rsteps, Trk::open, Trk::binR), binUtils);
 
  // DiscOverlapDescriptor takes possession of clonedBinUtils, will delete it on
  // destruction.
  //  but *does not* manage mergeBA.
  std::vector<Trk::BinUtility*>* clonedBinUtils = new std::vector<Trk::BinUtility*>();
  for (auto *bu : *binUtils) clonedBinUtils->push_back(bu->clone());
  auto olDescriptor = std::make_unique<InDet::DiscOverlapDescriptor>(mergeBA.get(),clonedBinUtils,true);
 
  // position & bounds of the disc layer
  double disc_thickness = std::fabs(zb.second-zb.first);
  double disc_pos = (zb.first+zb.second)*0.5;
 
  Amg::Transform3D transf;
  transf = Amg::Translation3D(0.,0.,disc_pos);
  Trk::BinnedArraySpan<Trk::Surface * const> layerSurfaces     = mergeBA->arrayObjects();
  // create disc layer
  // layer creation; deletes mergeBA in baseclass 'Layer' upon destruction
  Trk::DiscLayer* layer =
    new Trk::DiscLayer(transf,
                       new Trk::DiscBounds(rsteps.front(), rsteps.back()),
                       std::move(mergeBA),
                       // get the layer material from the first merged layer
                       *(inputDiscs[0]->layerMaterialProperties()),
                       disc_thickness,
                       std::move(olDescriptor));
 
  // register the layer to the surfaces
  for (const auto *sf : layerSurfaces) {
    const InDetDD::SiDetectorElement* detElement = dynamic_cast<const InDetDD::SiDetectorElement*>(sf->associatedDetectorElement());
    const std::vector<const Trk::Surface*>& allSurfacesVector = detElement->surfaces();
    for (const auto *subsf : allSurfacesVector){
      const_cast<Trk::Surface&>(*subsf).associateLayer(*layer);
    }
  }
 
  for (const auto *disc : inputDiscs)   {
    delete disc;      // cleanup
  }
 
  return layer;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

packVolumeTriple() [1/2]

Trk::TrackingVolume * InDet::StagedTrackingGeometryBuilderImpl::packVolumeTriple ( const std::vector< Trk::TrackingVolume * > &  negVolumes, const std::vector< Trk::TrackingVolume * > &  centralVolumes, const std::vector< Trk::TrackingVolume * > &  posVolumes, const std::string &  baseName = "UndefinedVolume"  ) const

protected

Private helper method, creates and packs a triple containing of NegEndcap-Barrel-PosEndcap volumes.

Definition at line 404 of file StagedTrackingGeometryBuilderImpl.cxx.

{
  ATH_MSG_VERBOSE( '\t' << '\t'<< "Pack provided Volumes from '" << baseName << "' triple into a container volume. " );
 
  unsigned int negVolSize = negVolumes.size();
  unsigned int cenVolSize = centralVolumes.size();
  unsigned int posVolSize = posVolumes.size();
 
 
 
    // create the strings
  std::string volumeBase = m_namespace+"Containers::"+baseName;
 
  Trk::TrackingVolume* negativeVolume = (negVolSize > 1) ?
       m_trackingVolumeCreator->createContainerTrackingVolume(negVolumes,
                                                       *m_materialProperties,
                                                       volumeBase+"::NegativeSector",
                                                       m_buildBoundaryLayers,
                                                       m_replaceJointBoundaries) :
                                             (negVolSize ? negVolumes[0] : nullptr);
  Trk::TrackingVolume* centralVolume = (cenVolSize > 1) ?
         m_trackingVolumeCreator->createContainerTrackingVolume(centralVolumes,
                                                       *m_materialProperties,
                                                       volumeBase+"::CentralSector",
                                                       m_buildBoundaryLayers,
                                                       m_replaceJointBoundaries) :
                                              (cenVolSize ? centralVolumes[0] : nullptr) ;
 
   Trk::TrackingVolume* positiveVolume = ( posVolSize > 1) ?
         m_trackingVolumeCreator->createContainerTrackingVolume(posVolumes,
                                                       *m_materialProperties,
                                                       volumeBase+"::PositiveSector",
                                                       m_buildBoundaryLayers,
                                                       m_replaceJointBoundaries) :
                                               (posVolSize ? posVolumes[0] : nullptr);
 
   if (!negativeVolume && !positiveVolume){
       ATH_MSG_DEBUG( "No negative/positive sector given - no packing needed, returning central container!" );
       return centralVolume;
   }
   // pack them together
   std::vector<Trk::TrackingVolume*> tripleVolumes;
   if (negativeVolume) tripleVolumes.push_back(negativeVolume);
   if (centralVolume) tripleVolumes.push_back(centralVolume);
   if (positiveVolume) tripleVolumes.push_back(positiveVolume);
   // create the tiple container
   Trk::TrackingVolume* tripleContainer =
         m_trackingVolumeCreator->createContainerTrackingVolume(tripleVolumes,
                                                                *m_materialProperties,
                                                                volumeBase,
                                                                m_buildBoundaryLayers,
                                                                m_replaceJointBoundaries);
   return tripleContainer;
}

packVolumeTriple() [2/2]

Trk::TrackingVolume * InDet::StagedTrackingGeometryBuilderImpl::packVolumeTriple ( InDet::LayerSetup &  layerSetup, double  rMin, double &  rMax, double  zMin, double  zPosCentral  ) const

protected

Private helper method, creates and packs a triple containing of NegEndcap-Barrel-PosEndcap layers.

• in case of a ring layout the subvolumes are created and the rMax is adapted

Definition at line 465 of file StagedTrackingGeometryBuilderImpl.cxx.

{
 
  ATH_MSG_VERBOSE( '\t' << '\t'<< "Pack provided Layers from '" << layerSetup.identification << "' triple into a container volume. " );
 
  // create the strings
  std::string volumeBase = m_namespace+"Detectors::"+layerSetup.identification;
 
  Trk::TrackingVolume* negativeVolume =
    createTrackingVolume(layerSetup.negativeLayers,
                         rMin,
                         rMax,
                         -zMax,
                         -zPosCentral,
                         volumeBase + "::NegativeEndcap",
                         (Trk::BinningType)layerSetup.binningEndcap,
                         false);
 
  Trk::TrackingVolume* centralVolume =
    m_trackingVolumeCreator->createTrackingVolume(
                                                  layerSetup.centralLayers,
                                                  *m_materialProperties,
                                                  rMin,
                                                  rMax,
                                                  -zPosCentral,
                                                  zPosCentral,
                                                  volumeBase + "::Barrel",
                                                  (Trk::BinningType)layerSetup.binningCenter);
 
  Trk::TrackingVolume* positiveVolume =
    createTrackingVolume(layerSetup.positiveLayers,
                         rMin,
                         rMax,
                         zPosCentral,
                         zMax,
                         volumeBase + "::PositiveEndcap",
                         (Trk::BinningType)layerSetup.binningEndcap,
                         false);
 
  // the base volumes have been created
  ATH_MSG_VERBOSE(
                  '\t' << '\t' << "Volumes have been created, now pack them into a triple.");
  // registerColorCode
  negativeVolume->registerColorCode(layerSetup.colorCode);
  centralVolume->registerColorCode(layerSetup.colorCode);
  positiveVolume->registerColorCode(layerSetup.colorCode);
 
  // pack them together
  std::vector<Trk::TrackingVolume*> tripleVolumes;
  tripleVolumes.push_back(negativeVolume);
  tripleVolumes.push_back(centralVolume);
  tripleVolumes.push_back(positiveVolume);
 
  // create the tiple container
  Trk::TrackingVolume* tripleContainer =
    m_trackingVolumeCreator->createContainerTrackingVolume(
                                                           tripleVolumes,
                                                           *m_materialProperties,
                                                           volumeBase,
                                                           m_buildBoundaryLayers,
                                                           m_replaceJointBoundaries);
 
  ATH_MSG_VERBOSE('\t' << '\t' << "Created container volume with bounds: "
                  << tripleContainer->volumeBounds());
 
  return tripleContainer;
}

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

ringLayout()

bool InDet::StagedTrackingGeometryBuilderImpl::ringLayout ( const std::vector< Trk::Layer * > &  layers, std::vector< double > &  rmins, std::vector< double > &  rmaxs  ) const

protected

Private helper method for detection of Ring layout.

Definition at line 237 of file StagedTrackingGeometryBuilderImpl.cxx.

                                                                                                                                                    {
  // get the maximum extent in z
  std::vector<std::pair<double,double>> radii;
  ATH_MSG_DEBUG("Checking for Ring layout ... ");
  for (auto *const ring : layers) {
    // Surface
    const Trk::Surface&     ringSurface = ring->surfaceRepresentation();
    const Trk::DiscBounds*  ringBounds  = dynamic_cast<const Trk::DiscBounds*>(&(ringSurface.bounds()));
    if (ringBounds){
      // get the main parameters
      double zpos         = ringSurface.center().z();
      double rMin         = ringBounds->rMin();
      double rMax         = ringBounds->rMax();
      // take and check the couple rmin/rmax
      checkForInsert(rMin, rMax, radii);
      ATH_MSG_DEBUG(" -> Ring at z-position " << zpos << " - with rMin/rMax = " << rMin << "/" << rMax );
    }
  }
 
  // you need a post processing of the (rmin,rmax) in order to fit z-overlapping disks in the same ring
  std::vector<std::pair<double,double>> tmpradii;
 
  for (auto& rs: radii) {
    bool found = false;
    for (auto& tmprs: tmpradii) {
      if ((rs.first<tmprs.second and rs.second>tmprs.first) ) {
        tmprs.first  = std::min(tmprs.first ,rs.first );
        tmprs.second = std::max(tmprs.second,rs.second);
        found = true;
        break;
      }
    }
    if (found) continue;
    tmpradii.push_back(rs);
  }
 
  // now you fill rmin and rmax
  rmins.clear(); rmaxs.clear();
  for (auto& r: tmpradii) {
    rmins.push_back(r.first);
    rmaxs.push_back(r.second);
  }
 
  //add rmin and rmax
  return (rmins.size() > 1 );
}

setBoundarySurface()

void Trk::TrackingVolumeManipulator::setBoundarySurface ( TrackingVolume &  tvol, SharedObject< BoundarySurface< TrackingVolume >>  bsurf, 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);
}

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() [1/2]

void Trk::TrackingVolumeManipulator::setInsideVolumeArray ( Trk::TrackingVolume &  tvol, Trk::BoundarySurfaceFace  face, 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(
    Trk::SharedObject<Trk::BinnedArray<Trk::TrackingVolume>>(insidevolarray));
}

setInsideVolumeArray() [2/2]

static void Trk::TrackingVolumeManipulator::setInsideVolumeArray ( TrackingVolume &  tvol, BoundarySurfaceFace  face, const SharedObject< 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

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 82 of file TrackingVolumeManipulator.cxx.

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

setOutsideVolumeArray() [1/2]

void Trk::TrackingVolumeManipulator::setOutsideVolumeArray ( Trk::TrackingVolume &  tvol, Trk::BoundarySurfaceFace  face, 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 91 of file TrackingVolumeManipulator.cxx.

{
 
  (tvol.m_boundarySurfaces)[face]->setOutsideVolumeArray(
    Trk::SharedObject<Trk::BinnedArray<Trk::TrackingVolume>>(outsidevolarray));
}

setOutsideVolumeArray() [2/2]

static void Trk::TrackingVolumeManipulator::setOutsideVolumeArray ( TrackingVolume &  tvol, BoundarySurfaceFace  face, const SharedObject< 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

setupFitsCache()

bool InDet::StagedTrackingGeometryBuilderImpl::setupFitsCache ( LayerSetup &  layerSetup, std::vector< InDet::LayerSetup > &  layerSetupCache  ) const

protected

Private helper method to check if a sector is compatible with the cache.

Definition at line 601 of file StagedTrackingGeometryBuilderImpl.cxx.

{
  // the maximum center and overall extend of the cache
  double maxCenterCacheZ = 0.;
  // the maximum endcap extend of the cache
  double minEndcapCacheZ = 10e10;
  // chech if he have a fullSectorSetup
  bool fullSectorSetup   = false;
  //
  for (const auto& lCacheSetup : layerSetupCache){
    takeBigger(maxCenterCacheZ, lCacheSetup.zExtendCenter);
    takeSmaller(minEndcapCacheZ, lCacheSetup.minZextendEndcap);
    // once true always true - otherwise it would have been flushed
    fullSectorSetup = lCacheSetup.buildEndcap ? true : fullSectorSetup;
 
  }
  // if we do not have a full sector setup - > flush directly
  if (!fullSectorSetup) {
    ATH_MSG_VERBOSE("       -> only central sector being built, flush the cache ... ");
    return false;
  }
  // if the cached minimum z endcap z extend cuts within the new barrel -> flush it
  if (minEndcapCacheZ < layerSetup.zExtendCenter){
    ATH_MSG_VERBOSE("       -> cache endcap extend reaches into new central sector, flush the cache ... ");
    return false;
  }
  // the cache center maximumg exceeds the new endcap minimum -> does not fit
  if (maxCenterCacheZ < layerSetup.minZextendEndcap ) {
    ATH_MSG_VERBOSE("       -> sector fully fits into cache! Add it and start synchronising ...");
    // calculate the new sector gap and synchronise
    double newCenterMaxZ = maxCenterCacheZ > layerSetup.zExtendCenter ? maxCenterCacheZ : layerSetup.zExtendCenter;
    double newEndcapMinZ = minEndcapCacheZ < layerSetup.minZextendEndcap ? minEndcapCacheZ : layerSetup.minZextendEndcap;
    double newSectorZ    = 0.5*(newCenterMaxZ+newEndcapMinZ);
    // and syncrhonise the boundaries
    for (auto& lCacheSetup : layerSetupCache)
      lCacheSetup.zSector = newSectorZ;
    layerSetup.zSector = newSectorZ;
    return true;
  }
  // it simply does not fit so return false
  return false;
}

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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.

trackingGeometryImpl()

std::unique_ptr< Trk::TrackingGeometry > InDet::StagedTrackingGeometryBuilderImpl::trackingGeometryImpl ( std::vector< InDet::LayerSetup > &  layerSetups, double  maximumLayerExtendZ, double  maximumLayerRadius, double  envelopeVolumeHalfZ, double  envelopeVolumeRadius  ) const

protected

Definition at line 69 of file StagedTrackingGeometryBuilderImpl.cxx.

{
    // create a volume cache for:
    // - ID volume, i.e. those that can be stacked into the overall container
    std::vector<Trk::TrackingVolume*> idVolumes;
    // create a layer setup cache for flushing when necessary
    std::vector<InDet::LayerSetup> layerSetupCache;
 
    // we only need to take care of the last flush radius
    double lastFlushRadius = 0.;
 
    // (I) PARSE THE LAYERS FOR OVERALL DIMENSIONS
    // -------------------------------------------------------------
    ATH_MSG_DEBUG(
        "[ STEP 2 ] : Looping through the layer setups and flush them into the "
        "ID detector volume vector.");
    for (auto& lSetup : layerSetups) {
      // screen output
      ATH_MSG_DEBUG("[ Layer setup: '"
                    << lSetup.identification
                    << "' ] being processed, current cache size is "
                    << layerSetupCache.size());
      ATH_MSG_VERBOSE(
          "       -> estimated dimensions for this layer setup are");
      ATH_MSG_VERBOSE("       -> central sector rMin / rMax / zMax : "
                      << lSetup.minRadiusCenter << " / "
                      << lSetup.maxRadiusCenter << " / "
                      << lSetup.zExtendCenter);
      // now check what is in the cache
      // [a] nothing in the cache or new setup is compatible (in this case
      // sectorZ are updated in all setups)
      if (layerSetupCache.empty() || setupFitsCache(lSetup, layerSetupCache)) {
        ATH_MSG_VERBOSE(
            "       -> cache is empty or new sector fits cache setup - add "
            "this one to the cache.");
      } else {
        // [b] cache is not empty - let's see what is going on:
        ATH_MSG_VERBOSE(
            "       -> new sector does not fit the current cache specs -> "
            "flushing the cache.");
        // create the outer boundary
        double flushRadius =
            0.5 *
            (layerSetupCache[layerSetupCache.size() - 1].rMax + lSetup.rMin);
        // create a flush volume - clears the cache
        Trk::TrackingVolume* fVolume = createFlushVolume(
            layerSetupCache, lastFlushRadius, flushRadius, maximumLayerExtendZ);
        // stuff it into the idVolume
        idVolumes.push_back(fVolume);
        // remember the last flush radius
        lastFlushRadius = flushRadius;
      }
      // in any case, this setup needs to go into the cache
      layerSetupCache.push_back(lSetup);
    }
 
    // check if the cache is empty
    if (!layerSetupCache.empty()) {
      ATH_MSG_DEBUG(
          "[ STEP 3 ] : Flush the remaining cache into the ID detector volume "
          "vector.");
      // set the maximum radius to the last layer radius
      double flushRadius = 0.5 * (maximumLayerRadius + envelopeVolumeRadius);
      Trk::TrackingVolume* fVolume = createFlushVolume(
          layerSetupCache, lastFlushRadius, flushRadius, maximumLayerExtendZ);
      // push it into the vector
      idVolumes.push_back(fVolume);
      lastFlushRadius = flushRadius;
    }
 
    ATH_MSG_DEBUG("[ STEP 4 ] : Create the ID detector volumes");
    // build the central enclosure first
    Trk::TrackingVolume* centralEnclosure =
        m_trackingVolumeCreator->createGapTrackingVolume(
            *m_materialProperties, lastFlushRadius, envelopeVolumeRadius,
            -maximumLayerExtendZ, maximumLayerExtendZ, 1, true,
            m_namespace + "Gaps::CentralEnclosure");
    idVolumes.push_back(centralEnclosure);
    // now lets create the container
    std::string volumeName = m_namespace + "Detectors::Container";
    Trk::TrackingVolume* idContainer =
        m_trackingVolumeCreator->createContainerTrackingVolume(
            idVolumes, *m_materialProperties, volumeName, m_buildBoundaryLayers,
            m_replaceJointBoundaries);
    // finally create the two endplates: negative
    Trk::TrackingVolume* negativeEnclosure =
        m_trackingVolumeCreator->createGapTrackingVolume(
            *m_materialProperties, 0., envelopeVolumeRadius,
            -envelopeVolumeHalfZ, -maximumLayerExtendZ, 1, false,
            m_namespace + "Gaps::NegativeEnclosure");
 
    // finally create the two endplates: positive
    Trk::TrackingVolume* positiveEnclosure =
        m_trackingVolumeCreator->createGapTrackingVolume(
            *m_materialProperties, 0., envelopeVolumeRadius,
            maximumLayerExtendZ, envelopeVolumeHalfZ, 1, false,
            m_namespace + "Gaps::PositiveEnclosure");
    // and the final tracking volume
    std::vector<Trk::TrackingVolume*> enclosedVolumes;
    enclosedVolumes.push_back(negativeEnclosure);
    enclosedVolumes.push_back(idContainer);
    enclosedVolumes.push_back(positiveEnclosure);
 
    Trk::TrackingVolume* enclosedDetector =
        m_trackingVolumeCreator->createContainerTrackingVolume(
            enclosedVolumes, *m_materialProperties, m_exitVolume,
            m_buildBoundaryLayers, m_replaceJointBoundaries);
 
    //  create the TrackingGeometry
    //  ------------------------------------------------------
    auto trackingGeometry =
        std::make_unique<Trk::TrackingGeometry>(enclosedDetector);
 
    if (m_indexStaticLayers) {
      ATH_MSG_VERBOSE("Re-index the static layers ...");
      trackingGeometry->indexStaticLayers(Trk::Global);
    }
    return trackingGeometry;
}

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_buildBoundaryLayers

BooleanProperty InDet::StagedTrackingGeometryBuilderImpl::m_buildBoundaryLayers

protected

Initial value:

{this, "BuildBoundaryLayers",
                                            true}

create boundary layers

Definition at line 259 of file StagedTrackingGeometryBuilderImpl.h.

m_checkForRingLayout

BooleanProperty InDet::StagedTrackingGeometryBuilderImpl::m_checkForRingLayout

protected

Initial value:

{
          this, "CheckForRingLayout",
          false}

this is to check for the endcap ring layout

Definition at line 271 of file StagedTrackingGeometryBuilderImpl.h.

m_colorCodesConfig

IntegerArrayProperty InDet::StagedTrackingGeometryBuilderImpl::m_colorCodesConfig

protected

Initial value:

{
          this, "ColorCodes", {}}

Color codes.

Definition at line 240 of file StagedTrackingGeometryBuilderImpl.h.

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_enclosingCylinderRadius

DoubleArrayProperty InDet::StagedTrackingGeometryBuilderImpl::m_enclosingCylinderRadius

protected

Initial value:

{
          this,
          "VolumeEnclosureCylinderRadii",
          {}}

the cylinder layer inside the enclosing volume

Definition at line 247 of file StagedTrackingGeometryBuilderImpl.h.

m_enclosingDiscPositionZ

DoubleArrayProperty InDet::StagedTrackingGeometryBuilderImpl::m_enclosingDiscPositionZ

protected

Initial value:

{
          this,
          "VolumeEnclosureDiscPositions",
          {}}

the disc position inside the enclosing volume

Definition at line 251 of file StagedTrackingGeometryBuilderImpl.h.

m_enclosingEnvelopeSvc

ServiceHandle<IEnvelopeDefSvc> InDet::StagedTrackingGeometryBuilderImpl::m_enclosingEnvelopeSvc

protected

Initial value:

{
          this, "EnvelopeDefinitionSvc",
          "AtlasEnvelopeDefSvc"}

the service to provide the ID envelope size

Definition at line 244 of file StagedTrackingGeometryBuilderImpl.h.

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_exitVolume

StringProperty InDet::StagedTrackingGeometryBuilderImpl::m_exitVolume

protected

Initial value:

{
          this, "ExitVolumeName",
          "InDet::Containers::InnerDetector"}

the final ID container

Definition at line 282 of file StagedTrackingGeometryBuilderImpl.h.

m_indexStaticLayers

BooleanProperty InDet::StagedTrackingGeometryBuilderImpl::m_indexStaticLayers

protected

Initial value:

{
          this, "IndexStaticLayers",
          true}

forces robust indexing for layers

Definition at line 266 of file StagedTrackingGeometryBuilderImpl.h.

m_layerArrayCreator

PublicToolHandle<Trk::ILayerArrayCreator> InDet::StagedTrackingGeometryBuilderImpl::m_layerArrayCreator

protected

Initial value:

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

Helper Tool to create BinnedArrays.

Definition at line 227 of file StagedTrackingGeometryBuilderImpl.h.

m_layerBinningTypeCenter

IntegerArrayProperty InDet::StagedTrackingGeometryBuilderImpl::m_layerBinningTypeCenter

protected

Initial value:

{
          this,
          "LayerBinningTypeCenter",
          {}}

binning type for the provided layers

Definition at line 232 of file StagedTrackingGeometryBuilderImpl.h.

m_layerBinningTypeEndcap

IntegerArrayProperty InDet::StagedTrackingGeometryBuilderImpl::m_layerBinningTypeEndcap

protected

Initial value:

{
          this,
          "LayerBinningTypeEndcap",
          {}}

binning type for the provided layers

Definition at line 236 of file StagedTrackingGeometryBuilderImpl.h.

m_layerEnvelopeCover

DoubleProperty InDet::StagedTrackingGeometryBuilderImpl::m_layerEnvelopeCover

protected

Initial value:

{
          this, "EnvelopeCover",
          2 * Gaudi::Units::mm}

innermost - outermost

Definition at line 256 of file StagedTrackingGeometryBuilderImpl.h.

m_materialProperties

CxxUtils::CachedUniquePtrT<Trk::Material> InDet::StagedTrackingGeometryBuilderImpl::m_materialProperties

protected

overal material properties of the ID

Definition at line 220 of file StagedTrackingGeometryBuilderImpl.h.

m_namespace

StringProperty InDet::StagedTrackingGeometryBuilderImpl::m_namespace

protected

Initial value:

{this, "VolumeNamespace",
                                 "InDet::"}

identificaton namespace

Definition at line 279 of file StagedTrackingGeometryBuilderImpl.h.

m_removeHGTD

BooleanProperty InDet::StagedTrackingGeometryBuilderImpl::m_removeHGTD {this, "RemoveHGTD", false}

protected

Definition at line 289 of file StagedTrackingGeometryBuilderImpl.h.

m_replaceJointBoundaries

BooleanProperty InDet::StagedTrackingGeometryBuilderImpl::m_replaceJointBoundaries

protected

Initial value:

{
          this, "ReplaceAllJointBoundaries",
          true}

run with replacement of all joint boundaries

Definition at line 261 of file StagedTrackingGeometryBuilderImpl.h.

m_ringTolerance

DoubleProperty InDet::StagedTrackingGeometryBuilderImpl::m_ringTolerance

protected

Initial value:

{
          this, "MinimalRadialGapForVolumeSplit",
          10 * Gaudi::Units::mm}

the ring tolerance

Definition at line 274 of file StagedTrackingGeometryBuilderImpl.h.

m_trackingVolumeCreator

PublicToolHandle<Trk::ITrackingVolumeCreator> InDet::StagedTrackingGeometryBuilderImpl::m_trackingVolumeCreator

protected

Initial value:

{
          this, "TrackingVolumeCreator",
          "Trk::CylinderVolumeCreator/CylinderVolumeCreator"}

< Helper Tool to create TrackingVolumes

Definition at line 224 of file StagedTrackingGeometryBuilderImpl.h.

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.

m_zMinHGTD

FloatProperty InDet::StagedTrackingGeometryBuilderImpl::m_zMinHGTD {this, "ZminHGTD", 3420.f}

protected

Definition at line 290 of file StagedTrackingGeometryBuilderImpl.h.

---

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

• StagedTrackingGeometryBuilderImpl.h
• StagedTrackingGeometryBuilderImpl.cxx