InDet::SiLayerBuilderImpl Class Reference

The SiLayerBuilderImpl parses the senstive detector elments and orders them onto a Layer surface. More...

#include <SiLayerBuilderImpl.h>

Inheritance diagram for InDet::SiLayerBuilderImpl:

Collaboration diagram for InDet::SiLayerBuilderImpl:

Public Member Functions
virtual	~SiLayerBuilderImpl ()=default
	Destructor.
virtual StatusCode	initialize () override
	AlgTool initialize method.
virtual StatusCode	finalize () override
	AlgTool finalize method.
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

Protected Member Functions
	SiLayerBuilderImpl (const std::string &, const std::string &, const IInterface *)
	AlgTool style constructor.
void	registerSurfacesToLayer (std::span< Trk::Surface *const > &layerSurfaces, Trk::Layer &lay) const
std::unique_ptr< const std::vector< Trk::CylinderLayer * > >	cylindricalLayersImpl (const InDetDD::SiDetectorElementCollection &siDetElementCollection) const
std::unique_ptr< std::vector< Trk::DiscLayer * > >	createDiscLayersImpl (const InDetDD::SiDetectorElementCollection &siDetElementCollection, std::unique_ptr< std::vector< Trk::DiscLayer * > > discLayers=nullptr) const
std::unique_ptr< std::vector< Trk::DiscLayer * > >	createRingLayersImpl (const InDetDD::SiDetectorElementCollection &siDetElementCollection) const
std::unique_ptr< std::vector< Trk::CylinderLayer * > >	dressCylinderLayers (const std::vector< Trk::CylinderLayer * > &dLayers) const
	helper method to construct barrel material
const Trk::BinnedLayerMaterial	barrelLayerMaterial (double r, double hz) const
	helper method to construct endcap material
const Trk::BinnedLayerMaterial	endcapLayerMaterial (double rMin, double rMax) const
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.

Protected Attributes
BooleanProperty	m_pixelCase {this, "PixelCase", true}
	Common properties.
const InDetDD::SiDetectorManager *	m_siMgr {}
	the Si Detector Manager
StringProperty	m_siMgrLocation {this, "SiDetManagerLocation", "Pixel"}
	the location of the Pixel Manager
const PixelID *	m_pixIdHelper {}
	pixel Id Helper
const SCT_ID *	m_sctIdHelper {}
	sct Id Helper
BooleanProperty	m_setLayerAssociation {this, "SetLayerAssociation", true}
	Set Layer Association.
DoubleArrayProperty	m_barrelAdditionalLayerR {this, "BarrelAdditionalLayerRadii", {} }
	Create an additional layer at these radii.
IntegerArrayProperty	m_barrelAdditionalLayerType {this, "BarrelAdditionalLayerType", {} }
	material layer 1 - navigation layer 0
UnsignedIntegerProperty	m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 100}
	Barrel bins for the material in z.
UnsignedIntegerProperty	m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}
	Barrel bins for the material in phi.
DoubleProperty	m_barrelEnvelope {this, "BarrelEnvelope", 0.1}
	envelope around rMin/rMax
DoubleProperty	m_barrelEdbTolerance {this, "BarrelEdbTolerance", 0.05}
	tolerance in percent how much the bin sizes can change
DoubleArrayProperty	m_endcapAdditionalLayerPosZ {this, "EndcapAdditionalLayerPositionsZ", {} }
	Create additional endcaps at these z positions.
IntegerArrayProperty	m_endcapAdditionalLayerType {this,"EndcapAdditionalLayerType" , {} }
	material layer 1 - navigation layer 0 ( for volume adjustment )
UnsignedIntegerProperty	m_endcapLayerBinsR {this, "EndcapLayerBinsR", 100}
	Barrel bins for the material in r.
UnsignedIntegerProperty	m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}
	Barrel bins for the material in phi.
DoubleProperty	m_endcapEnvelope {this, "EndcapEnvelope", 0.1}
	envelope around rMin/rMax
BooleanProperty	m_endcapComplexRingBinning {this, "EndcapComplexRingBinning", true}
	make std::vector<R> rings, could be different for layers
StringProperty	m_identification {this, "Identification", "Pixel"}
	string identification
BooleanProperty	m_runGeometryValidation {this, "GeometryValidation", true}
	run the validation of the geometry ( no empty bins)
IntegerArrayProperty	m_layerIndicesBarrel {this, "LayerIndicesBarrel", {} }
	indices to be used for layer creation (used for ITk specific case)
IntegerArrayProperty	m_layerIndicesEndcap {this, "LayerIndicesEndcap", {} }
	indices to be used for layer creation (used for ITk specific case)
BooleanProperty	m_useRingLayout {this, "UseRingLayout", false}
	to enable creation of rings for ITk pixel geometry (used for ITk specific case)
BooleanProperty	m_addMoreSurfaces {this, "AddMoreSurfaces", false}
	to add additional surfaces to the PixelOverlapDescriptor, SCT_OverlapDescriptor and DiscOverlapDescriptor (used for ITk specific case)
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCT_ReadKey {this, "SCT_ReadKey", "SCT_DetectorElementCollection", "Key of output SiDetectorElementCollection for SCT"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_PixelReadKey {this, "PixelReadKey", "PixelDetectorElementCollection", "Key of output SiDetectorElementCollection for Pixel"}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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

Detailed Description

The SiLayerBuilderImpl parses the senstive detector elments and orders them onto a Layer surface.

It also uses the SiNumerology to construct the BinUtility and then orders the representing detector surfaces on the layers.

It performs an automated detector if an equidistant or non-equidistant binning is to be used for the barrel case.

Author

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

Definition at line 59 of file SiLayerBuilderImpl.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~SiLayerBuilderImpl()

virtual InDet::SiLayerBuilderImpl::~SiLayerBuilderImpl ( )

virtualdefault

Destructor.

SiLayerBuilderImpl()

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

protected

AlgTool style constructor.

Definition at line 27 of file SiLayerBuilderImpl.cxx.

                                                                                                       :
  AthAlgTool(t,n,p)
{
}

Member Function Documentation

barrelLayerMaterial()

const Trk::BinnedLayerMaterial InDet::SiLayerBuilderImpl::barrelLayerMaterial ( double r, double hz ) const

protected

helper method to construct endcap material

Definition at line 1246 of file SiLayerBuilderImpl.cxx.

{
  // --------------- material estimation ----------------------------------------------------------------
  // -- material with 1D binning
  Trk::BinUtility layerBinUtilityZ(m_barrelLayerBinsZ, -hz, hz, Trk::open, Trk::binZ);
  auto & layerBinUtility(layerBinUtilityZ);
  if (m_barrelLayerBinsPhi!=1u){ // -- material with 2D binning
      Trk::BinUtility layerBinUtilityRPhiZ(m_barrelLayerBinsPhi,
                                                 -r*M_PI, r*M_PI,
                                                 Trk::closed,
                                                 Trk::binRPhi);
      layerBinUtilityRPhiZ += layerBinUtilityZ;
      layerBinUtility =  std::move(layerBinUtilityRPhiZ);
  }
  // --------------- material estimation ----------------------------------------------------------------
  return Trk::BinnedLayerMaterial(layerBinUtility);
}

createDiscLayersImpl()

std::unique_ptr< std::vector< Trk::DiscLayer * > > InDet::SiLayerBuilderImpl::createDiscLayersImpl ( const InDetDD::SiDetectorElementCollection & siDetElementCollection, std::unique_ptr< std::vector< Trk::DiscLayer * > > discLayers = nullptr ) const

protected

Definition at line 392 of file SiLayerBuilderImpl.cxx.

{
  // this is the DBM flag
  bool isDBM = (discLayers!=nullptr);
 
  // save way to estimate the number of barrels
  unsigned int endcapLayers = 0;
  if (isDBM){
     endcapLayers = m_siMgr->numerology().numDisksDBM();
     ATH_MSG_DEBUG( "Configured to build " << endcapLayers << "*2 disc-like DBM layers" );
  } else {
      for (int i = 0; i < m_siMgr->numerology().numDisks(); i++)
          if (m_siMgr->numerology().useDisk(i)) endcapLayers++;
     ATH_MSG_DEBUG( "Configured to build " << endcapLayers << " *2 disc-like layers  (+ additional support layers)." );
  }
 
  // prepare the vectors
  std::vector<double>                                     discZmin(2*endcapLayers,10e10);
  std::vector<double>                                     discZmax(2*endcapLayers,-10e10);
  std::vector<double>                                     discZpos(2*endcapLayers,0.);
  std::vector<double>                                     discRmin(2*endcapLayers,10e10);
  std::vector<double>                                     discRmax(2*endcapLayers,0);
  std::vector<double>                                     discThickness(2*endcapLayers,0.);
 
  std::vector< std::vector<Trk::SurfaceOrderPosition> >   discSurfaces;
  std::vector< std::vector<int> >                         discPhiSectors;
  std::vector< std::vector<double> >                      discPhiMin;
  std::vector< std::vector<double> >                      discPhiMax;
  std::vector< std::vector<double> >                      discRingMinR;
  std::vector< std::vector<double> >                      discRingMaxR;
 
  // let's make sure the discs are ordered in z: that's the z / map index
  std::map< double, int>                                  discZposLayerIndex;
 
  // reserve -- better memory management
  discPhiMin.reserve(2*endcapLayers);
  discPhiMax.reserve(2*endcapLayers);
  discPhiSectors.reserve(2*endcapLayers);
  discSurfaces.reserve(2*endcapLayers);
  discRingMinR.reserve(2*endcapLayers);
  discRingMaxR.reserve(2*endcapLayers);
 
  // initialize for checks (pos/neg discs -> 2 times discs)
  for (unsigned int endcap=0; endcap<2*endcapLayers; endcap++){
        discPhiMin.emplace_back();
        discPhiMax.emplace_back();
        discPhiSectors.emplace_back();
        discSurfaces.emplace_back( );
        // auto-detection
        discRingMinR.emplace_back();
        discRingMaxR.emplace_back();
   } // end of for loop
 
  int endcapModules = 0;
  int sumCheckEndcapModules = 0;
  unsigned int currentlayer = 0;
  unsigned int currentdisk  = 0;
  unsigned int currentring  = 0;
 
  // [-A1-] ------------------------ first LOOP over Detector Elements of sensitive layers -------------------------------
  // -- get the missing dimensions by loop over DetElements
  const InDetDD::SiDetectorElementCollection::const_iterator sidetBegin = siDetElementCollection.begin();
  const  InDetDD::SiDetectorElementCollection::const_iterator sidetEnd = siDetElementCollection.end();
  InDetDD::SiDetectorElementCollection::const_iterator sidetIter = sidetBegin;
  for (; sidetIter != sidetEnd; ++sidetIter){
     // take it - if
     // a) you have a detector element ... protection
     // b) the detector element is EC (in the non-DBM case)
     // c) the detector elemet is DBM in the DBM case
     if ( (*sidetIter) && ( (!isDBM && (*sidetIter)->isEndcap()) || (isDBM && (*sidetIter)->isDBM())) ){
 
       // increase the counter of endcap modules
        endcapModules++;
        // parse all z positions for the mean value of the discs
        double currentZ = (*sidetIter)->center().z();
        // get the identifier & calculate current layer and current disk from it
        Identifier    currentId((*sidetIter)->identify());
        currentdisk  = m_pixIdHelper ? m_pixIdHelper->layer_disk(currentId) : m_sctIdHelper->layer_disk(currentId);
        currentlayer = currentdisk;
        currentlayer += currentZ > 0. ? endcapLayers : 0;
 
        // check the current ring
        currentring = m_pixIdHelper ? m_pixIdHelper->eta_module(currentId) : m_sctIdHelper->eta_module(currentId);
 
        takeSmallerBigger(discZmin[currentlayer],discZmax[currentlayer],currentZ);
 
        // set the disc Rmin / Rmax
        double currentRmin = (*sidetIter)->rMin();
        double currentRmax = (*sidetIter)->rMax();
 
        // how many rings do we have ?
        unsigned int diskRings =  isDBM ?
            m_siMgr->numerology().numRingsForDiskDBM(currentdisk) :
            m_siMgr->numerology().numRingsForDisk(currentdisk);
 
        // the current phi
        double currentPhi = (*sidetIter)->center().phi();
        takeSmaller(discRmin[currentlayer],currentRmin);
        takeBigger( discRmax[currentlayer],currentRmax);
 
        //fill the number of phi sectors for the different rings
        if (discPhiSectors[currentlayer].empty()){
           ATH_MSG_VERBOSE("Pre-processing Elements from Disk/Layer (id from idHelper): " << currentdisk << "/" << currentlayer );
           // prepare the ring bins, initialise the first one to be something big
           discPhiMin[currentlayer]      = std::vector<double>(diskRings,100.);
           discPhiMax[currentlayer]      = std::vector<double>(diskRings,-100.);
           discRingMinR[currentlayer]    = std::vector<double>(diskRings,1e10);
           discRingMaxR[currentlayer]    = std::vector<double>(diskRings,0);
           // fill the phi sectors
           ATH_MSG_VERBOSE("-> The current disk has " << diskRings << " ring(s)");
           for (unsigned int iring=0; iring < diskRings; ++iring){
               unsigned int phiSectorsRing = isDBM ?
                   m_siMgr->numerology().numPhiModulesForDiskRingDBM(currentdisk, iring) :
                   m_siMgr->numerology().numPhiModulesForDiskRing(currentdisk, iring);
              // get the number of phi sectors
              ATH_MSG_VERBOSE("--> Ring " << iring << " has " << phiSectorsRing << " phi sectors");
              discPhiSectors[currentlayer].push_back(phiSectorsRing);
           }
        }
        // we take the phi / r binning only from the closer to IP module
        if ( !(*sidetIter)->otherSide() || std::abs(currentZ) < std::abs((*sidetIter)->otherSide()->center().z())){
            // take phi-min and phimax
            takeSmaller(discPhiMin[currentlayer][currentring],currentPhi);
            takeBigger(discPhiMax[currentlayer][currentring],currentPhi);
            // record the smalles ring & biggest ring radius
            takeSmaller(discRingMinR[currentlayer][currentring],currentRmin);
            takeBigger(discRingMaxR[currentlayer][currentring],currentRmax);
        }
     } else if (!(*sidetIter))
        ATH_MSG_WARNING("nullptr to Endcap module given by SCT_DetectorManager! Please check db & dict.xml");
  } // DetElement loop
 
  double minRmin = 10e10;
  double maxRmax = -10e10;
 
  ATH_MSG_VERBOSE("Estimating the average z position and the radius for each disk.");
  // get the average z-position per layer & estimate thes thickness
  for (unsigned int iec=0; iec<2*endcapLayers; ++iec){
       takeSmaller(minRmin,discRmin[iec]); takeBigger(maxRmax,discRmax[iec]);
       // average it out
       discZpos[iec]        = 0.5 * (discZmin[iec] + discZmax[iec]);
       discThickness[iec]   = isDBM ? 1. : std::abs(discZmax[iec]-discZmin[iec]);
       // make the map z / index
       discZposLayerIndex.insert(std::make_pair(discZpos[iec],iec));
  }
 
  // [-A2-] ------------------------ second LOOP over Detector Elements of sensitive layers -------------------------------
  // fill the elements for the layers into the surface arrays
  sidetIter = sidetBegin;
  for (; sidetIter != sidetEnd; ++sidetIter){
    // Endcap
    if ( ((*sidetIter) && ((!isDBM && (*sidetIter)->isEndcap()) || (isDBM && (*sidetIter)->isDBM()))) ){
        // get the identifier & calculate current layer and current disk from it
        Identifier    currentId((*sidetIter)->identify());
        currentdisk  = m_pixIdHelper ? m_pixIdHelper->layer_disk(currentId) : m_sctIdHelper->layer_disk(currentId);
        currentlayer = currentdisk;
        currentlayer += (*sidetIter)->center().z() > 0. ? endcapLayers : 0;
        // decision which module to take
        const InDetDD::SiDetectorElement* otherSide = (*sidetIter)->otherSide();
        bool takeIt =  (!otherSide || std::abs((*sidetIter)->center().z()) < std::abs(otherSide->center().z()) );
        const InDetDD::SiDetectorElement* chosenSide = takeIt ?  (*sidetIter) : otherSide;
        // get the center position
        const Amg::Vector3D& orderPosition = chosenSide->center();
        // register the chosen side in the object array
        // Something like
        // std::shared_ptr<Trk::Surface>  =
        // std::make_shared<Trk::Surface>(detElement)) could be fine
        //
        // As things are now
        // 1) Notice that basically we couple the DetElement owned
        // surface to the Tracking Geometry passing a no-op deleter
        // (no delete happens) to the shared_ptr(SharedObject is
        // typedef of shared_ptr)
        // 2) The const_cast here make the
        // code non MT safe. For now we handle this by being careful
        // on lifetimes and non-re-entrant TG construction.
 
        std::shared_ptr<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(&(chosenSide->surface())),
                                                      [](Trk::Surface*){});
        Trk::SurfaceOrderPosition surfaceOrder(sharedSurface, orderPosition);
        if (takeIt) (discSurfaces[currentlayer]).push_back(std::move(surfaceOrder));
    }
  } //end of filling
 
  // [-B-] ------------------------ Construction of the layers -----------------------------------
  // construct the layers
  if (!discLayers) {
    discLayers = std::make_unique<std::vector< Trk::DiscLayer* > >();
  }
  std::vector<double>::iterator discZposIter = discZpos.begin();
  int discCounter = 0;
 
  for ( ; discZposIter != discZpos.end(); ++discZposIter){
       // the gathered R sectors
       size_t discRsectors = (discPhiSectors[discCounter]).size();
       // dynamic estimation 1: estimate the layer thickness dynamically
       double thickness = discThickness[discCounter]+m_endcapEnvelope;
       // put rMin in and sort the bins
       std::vector<double> discRingMinRcopy = discRingMinR[discCounter];
       std::sort(discRingMinRcopy.begin(), discRingMinRcopy.end());
       bool reverseRsectors = !(discRingMinRcopy == discRingMinR[discCounter]);
 
       // this causes a reverse order for the phi sectors
       if (reverseRsectors){
           ATH_MSG_VERBOSE("Auto-detect: rings in R are in " << ( reverseRsectors ? "reversed" : "standard") << " order.");
           std::reverse(discPhiSectors[discCounter].begin(),discPhiSectors[discCounter].end());
           std::reverse(discPhiMin[discCounter].begin(),discPhiMin[discCounter].end());
           std::reverse(discPhiMax[discCounter].begin(),discPhiMax[discCounter].end());
           std::reverse(discRingMaxR[discCounter].begin(),discRingMaxR[discCounter].end());
       }
       // preperare the rboundaries
       std::vector<float> discRboundaries;
       discRboundaries.push_back(float(*discRingMinRcopy.begin()));
       for (double & ringMaxRIter : discRingMaxR[discCounter])
           discRboundaries.push_back(float(ringMaxRIter));
 
       // screen output
       ATH_MSG_DEBUG( "Building a DiscLayer with " << discRsectors << " R sectors. " );
       ATH_MSG_DEBUG( "  -> At Z - Position      :  " << discZpos[discCounter] );
       ATH_MSG_DEBUG( "  -> With Thickness       :  " << thickness   << " i- ncludes envelope tolerance : " << m_endcapEnvelope );
       ATH_MSG_DEBUG( "  -> With Rmin/Rmax (est) :  " << discRmin[discCounter] << " / " << discRmax[discCounter] );
       ATH_MSG_DEBUG( "  -> With Rings           :  " << discRsectors );
 
       for (size_t irings=0; irings<discRsectors; ++irings)
         ATH_MSG_DEBUG( " --> " << irings <<  " R sector has " << discPhiSectors[discCounter][irings] << " phi sectors. " );
 
       // prepare the binned array, it can be with one to several rings
       std::unique_ptr<Trk::BinnedArray<Trk::Surface>> currentBinnedArray = nullptr;
       auto singleBinUtils = std::vector<Trk::BinUtility>();
       if (discRsectors==1){
            double halfPhiStep = M_PI/discPhiSectors[discCounter][0];
            // protection in case phi value was fluctuating around 0 or M_PI in parsing
            if (std::abs(discPhiMin[discCounter][0]+discPhiMax[discCounter][0])< halfPhiStep && std::abs(discPhiMin[discCounter][0]) < 0.5*halfPhiStep ){
                ATH_MSG_VERBOSE("Detected module fluctuation around +/- M_PI, correcting for it.");
                ATH_MSG_VERBOSE("    min phi / max phi detected  : "  << discPhiMin[discCounter][0] << " / " <<discPhiMax[discCounter][0] );
                discPhiMin[discCounter][0] += 2*halfPhiStep;
            }
            // prepare min phi and max phi & eventually a sub stepvalue
            ATH_MSG_VERBOSE("    min phi / max phi detected  : " << discPhiMin[discCounter][0] << " / " << discPhiMax[discCounter][0] );
            double minPhiCorrected = discPhiMin[discCounter][0]-halfPhiStep;
            double maxPhiCorrected = discPhiMax[discCounter][0]+halfPhiStep;
            // catch if the minPhi falls below M_PI
            if (minPhiCorrected < -M_PI){
                minPhiCorrected += 2*halfPhiStep;
                maxPhiCorrected += 2*halfPhiStep;
            }
            ATH_MSG_VERBOSE("    min phi / max phi corrected : " << minPhiCorrected << " / " << maxPhiCorrected );
 
            ATH_MSG_VERBOSE("Constructing a one-dimensional BinnedArray with phiMin / phiMax (bins) = "
                << minPhiCorrected << " / " << maxPhiCorrected
                << " (" << discPhiSectors[discCounter][0] << ")");
            // an easier bin utility can be used
            auto currentBinUtility = Trk::BinUtility(discPhiSectors[discCounter][0] ,
                                                     minPhiCorrected,
                                                     maxPhiCorrected,
                                                     Trk::closed,
                                                     Trk::binPhi);
            // a one-dimensional BinnedArray is sufficient
            currentBinnedArray = std::make_unique<Trk::BinnedArray1D<Trk::Surface>>(discSurfaces[discCounter],currentBinUtility);
        } else {
            ATH_MSG_VERBOSE("Constructing a two-dimensional BinnedArray.");
            // get the binning in R first (can still be improved with non-aequidistant binning)
            Trk::BinUtility currentSteerBinUtility{};
            if (m_endcapComplexRingBinning && discRsectors > 1 ){
                // respecting the actual element boundaires
                ATH_MSG_VERBOSE("Non-equidistant binning detected.");
                // now create the bin utility
                currentSteerBinUtility = Trk::BinUtility(discRboundaries,
                                                         Trk::open,
                                                         Trk::binR);
             } else
                currentSteerBinUtility =  Trk::BinUtility(discRsectors,
                                                          discRmin[discCounter],
                                                          discRmax[discCounter],
                                                          Trk::open,
                                                          Trk::binR);
            ATH_MSG_VERBOSE("Steering bin utility constructed as : " << currentSteerBinUtility);
            // the single phi bin utilities
            //std::vector<Trk::BinUtility*>* singleBinUtils = new std::vector<Trk::BinUtility*>;
            singleBinUtils.reserve(discRsectors);
            for (size_t irings=0; irings < discRsectors; ++irings){
                    double halfPhiStep = M_PI/discPhiSectors[discCounter][irings];
                    ATH_MSG_VERBOSE("    min phi / max phi detected  : " << discPhiMin[discCounter][irings] << " / " << discPhiMax[discCounter][irings] );
                    double minPhiCorrected = discPhiMin[discCounter][irings]-halfPhiStep;
                    double maxPhiCorrected = discPhiMax[discCounter][irings]+halfPhiStep;
                    // catch if the minPhi falls below M_PI
                    if (minPhiCorrected < -M_PI){
                        minPhiCorrected += 2*halfPhiStep;
                        maxPhiCorrected += 2*halfPhiStep;
                    }
                    ATH_MSG_VERBOSE("    min phi / max phi corrected : " << minPhiCorrected << " / " << maxPhiCorrected );
                    ATH_MSG_VERBOSE("Constructing for ring " << irings << " phi utility with phiMin / phiMax (bins) = "
                        <<  minPhiCorrected << " / " << maxPhiCorrected << " (" << discPhiSectors[discCounter][irings] << ")") ;
                    singleBinUtils.emplace_back(discPhiSectors[discCounter][irings],
                                                             minPhiCorrected,
                                                             maxPhiCorrected,
                                                             Trk::closed,
                                                             Trk::binPhi);
            }
            // a two-dimensional BinnedArray is needed
            currentBinnedArray =
                std::make_unique<Trk::BinnedArray1D1D<Trk::Surface>>(
                    discSurfaces[discCounter], currentSteerBinUtility,
                    singleBinUtils);
        }
 
        int discSurfacesNum = (discSurfaces[discCounter]).size();
        ATH_MSG_DEBUG( "Constructed BinnedArray for DiscLayer with "<< discSurfacesNum << " SubSurfaces." );
 
        // always run the geometry validation to catch flaws
        // checking for :
        //   - empty surface bins
        //   - doubly filled bins
        std::map< const Trk::Surface*,Amg::Vector3D > uniqueSurfaceMap;
        std::map< const Trk::Surface*,Amg::Vector3D >::iterator usmIter = uniqueSurfaceMap.end();
        // check the registered surfaces in the binned array
        std::span<Trk::Surface * const> arraySurfaces = currentBinnedArray->arrayObjects();
        size_t dsumCheckSurfaces = 0;
        double lastPhi = 0.;
        for (const auto & asurfIter : arraySurfaces){
            if ( asurfIter ) {
                ++dsumCheckSurfaces;
                usmIter = uniqueSurfaceMap.find(asurfIter);
                lastPhi = asurfIter->center().phi();
                if ( usmIter != uniqueSurfaceMap.end() )
                    ATH_MSG_WARNING("Non-unique surface found with eta/phi = " << asurfIter->center().eta() << " / " << asurfIter->center().phi());
                else uniqueSurfaceMap[asurfIter] = asurfIter->center();
            } else
                ATH_MSG_WARNING("Zero-pointer in array detected in this ring, last valid phi value was = " << lastPhi);
        }
        sumCheckEndcapModules +=  dsumCheckSurfaces;
 
        ATH_MSG_DEBUG( "  -> With Rmin/Rmax (corr) :  " << minRmin << " / " << maxRmax );
 
        // get the layer material from the helper method
        const Trk::LayerMaterialProperties& layerMaterial = endcapLayerMaterial(minRmin,maxRmax);
 
        // position & bounds of the active Layer
        Amg::Transform3D activeLayerTransform ;
        activeLayerTransform = Amg::Translation3D(0.,0.,discZpos[discCounter]);
 
        auto activeLayerBounds    = std::make_shared<Trk::DiscBounds>(minRmin,maxRmax);
        // prepare the right overlap descriptor
        std::unique_ptr<Trk::OverlapDescriptor> olDescriptor = nullptr;
        if (m_pixelCase){
            olDescriptor = std::make_unique<InDet::PixelOverlapDescriptor>();
        } else {
            auto binUtils = std::vector<Trk::BinUtility>();
            if (!singleBinUtils.empty()) {
                auto binIter = singleBinUtils.begin();
                for (; binIter != singleBinUtils.end(); ++binIter) {
                    binUtils.push_back((*binIter));
                }
            }
            // DiscOverlapDescriptor takes possession of binUtils, will delete
            // it on destruction.
            //  but *does not* manage currentBinnedArray.
            olDescriptor =
                std::make_unique<InDet::DiscOverlapDescriptor>(currentBinnedArray.get(), binUtils);
        }
        // register the layer to the surfaces --- if necessary to the other sie
        // as well
        std::span<Trk::Surface * const> layerSurfaces     = currentBinnedArray->arrayObjects();
        // layer creation; deletes currentBinnedArray in baseclass 'Layer' upon destruction
        // activeLayerTransform deleted in 'Surface' baseclass
        Trk::DiscLayer* activeLayer =
            new Trk::DiscLayer(activeLayerTransform, std::move(activeLayerBounds),
                               std::move(currentBinnedArray), layerMaterial,
                               thickness, std::move(olDescriptor));
       registerSurfacesToLayer(layerSurfaces,*activeLayer);
        discLayers->push_back(activeLayer);
       // increase the disc counter by one
       ++discCounter;
  }
 
  // multiply the check modules for SCT case
  sumCheckEndcapModules *= (m_pixelCase) ? 1 : 2;
  ATH_MSG_DEBUG( endcapModules << " Endcap Modules parsed for Disc Layer dimensions." );
  ATH_MSG_DEBUG( sumCheckEndcapModules << " Endcap Modules filled in Disc Layer Arrays." );
  if ( endcapModules-sumCheckEndcapModules )
     ATH_MSG_WARNING( endcapModules-sumCheckEndcapModules << " Modules not registered properly in binned array." );
 
 
  // sort the vector
  Trk::DiscLayerSorterZ zSorter;
  std::vector<Trk::DiscLayer*>::iterator sortIter = discLayers->begin();
  std::vector<Trk::DiscLayer*>::iterator sortEnd   = discLayers->end();
  std::sort(sortIter, sortEnd, zSorter);
 
  // if there are additional layers to be built - never build for the DBM loop
  if (!m_endcapAdditionalLayerPosZ.empty() && !isDBM){
      //
      const std::size_t originalSize = discLayers->size();
      std::size_t layerIndex = 0;
      //
      // sort also the additional layer z positions
      auto addLayerIter     = m_endcapAdditionalLayerPosZ.begin();
      auto addLayerTypeIter = m_endcapAdditionalLayerType.begin();
      // get the last rmin / rmax
      double lastRmin = 0.;
      double lastRmax = 0.;
      //
      while (layerIndex < originalSize || addLayerIter != m_endcapAdditionalLayerPosZ.end() ){
          // cache before last parameters are overwritten
          double layerRmin       = lastRmin;
          double layerRmax       = lastRmax;
          double layerZposition   = 0.;
          // check if the z-position is smaller than the
          if ( layerIndex < originalSize){
              const auto * layer = (*discLayers)[layerIndex];
              // get the current z position to guarantee a symmetrical setup
              layerZposition = layer->surfaceRepresentation().center().z();
              // get the bounds for the rMin / rMax setting
              const auto* bounds = dynamic_cast<const Trk::DiscBounds*>(&layer->surfaceRepresentation().bounds());
              lastRmin = bounds ? bounds->rMin() : 0.;
              lastRmax = bounds ? bounds->rMax() : 0.;
              ++layerIndex;
          }
          if ( addLayerIter != m_endcapAdditionalLayerPosZ.end()){
              // symmetric setup around 0.
              double rMin = layerZposition > 0. ? layerRmin : lastRmin;
              double rMax = layerZposition > 0. ? layerRmax : lastRmax;
              // the passive layer
              Trk::DiscLayer* passiveLayer = nullptr;
              // passive layer creation
              Amg::Transform3D passiveDiscTransf =
                Amg::Transform3D(Amg::Translation3D(0., 0., *addLayerIter));
              if (*addLayerTypeIter) {
                ATH_MSG_DEBUG( "Building an additional DiscLayer w/o sensitive modules at");
                // create the material and the passive layer
                const Trk::LayerMaterialProperties& passiveLayerMaterial = endcapLayerMaterial(rMin, rMax);
                passiveLayer = new Trk::DiscLayer(passiveDiscTransf,
                                     std::make_shared<Trk::DiscBounds>(rMin, rMax),
                                     passiveLayerMaterial,
                                     1. * Gaudi::Units::mm);
              } else
                passiveLayer = new Trk::DiscLayer(
                  passiveDiscTransf, std::make_shared<Trk::DiscBounds>(rMin, rMax), nullptr);
              ATH_MSG_DEBUG( "  -> At Z - Position       :  " << *addLayerIter );
              ATH_MSG_DEBUG( "  -> With Rmin/Rmax (corr) :  " << rMin << " / " << rMax );
 
              // increase the iterator and push back the new layer
             ++addLayerIter;
             ++addLayerTypeIter;
             discLayers->push_back(passiveLayer);
          }
      } // the additional layers are built
 
    // another round of sorting needed after adding the passive layers
    
    std::ranges::sort(*discLayers,zSorter);
  }
 
  return discLayers;
}

createRingLayersImpl()

std::unique_ptr< std::vector< Trk::DiscLayer * > > InDet::SiLayerBuilderImpl::createRingLayersImpl ( const InDetDD::SiDetectorElementCollection & siDetElementCollection ) const

protected

Definition at line 75 of file SiLayerBuilderImpl.cxx.

{
  // save way to estimate the number of barrels
  unsigned int endcapLayers = 0;
  for (int i = 0; i < m_siMgr->numerology().numDiskLayers(); i++) {
    if (not m_layerIndicesEndcap.empty() and
      std::find(m_layerIndicesEndcap.begin(), m_layerIndicesEndcap.end(), i)==m_layerIndicesEndcap.end() ) continue;
    if (m_siMgr->numerology().useDiskLayer(i)) {
      endcapLayers+=m_siMgr->numerology().numDisksForLayer(i);
    }
  }
 
  ATH_MSG_DEBUG( "Configured to build " << endcapLayers << " *2 disc-like layers  (+ additional support layers)." );
 
  // prepare the vectors
  std::vector<double>                                     discZmin(2*endcapLayers,10e10);
  std::vector<double>                                     discZmax(2*endcapLayers,-10e10);
  std::vector<double>                                     discZpos(2*endcapLayers,0.);
  std::vector<double>                                     discRmin(2*endcapLayers,10e10);
  std::vector<double>                                     discRmax(2*endcapLayers,0);
  std::vector<double>                                     discThickness(2*endcapLayers,0.);
  std::vector<int>                                        discPhiSectors(2*endcapLayers,-1);
  std::vector<double>                                     discPhiMin(2*endcapLayers,10e10);
  std::vector<double>                                     discPhiMax(2*endcapLayers,-10e10);
  std::vector< std::vector<Trk::SurfaceOrderPosition> >   discSurfaces(2*endcapLayers, std::vector<Trk::SurfaceOrderPosition>());
 
  // let's make sure the discs are ordered in z: that's the z / map index
  std::map< double, int>                                  discZposLayerIndex;
 
  int endcapModules = 0;
  int sumCheckEndcapModules = 0;
  unsigned int currentdisk  = 0;
  unsigned int currentring  = 0;
  unsigned int currentlayer = 0;
 
  // [-A-] ------------------------ first LOOP over Detector Elements of sensitive layers -------------------------------
  // -- get the missing dimensions by loop over DetElements
  const InDetDD::SiDetectorElementCollection::const_iterator sidetBegin = siDetElementCollection.begin();
  const  InDetDD::SiDetectorElementCollection::const_iterator sidetEnd = siDetElementCollection.end();
  InDetDD::SiDetectorElementCollection::const_iterator sidetIter = sidetBegin;
  for (; sidetIter != sidetEnd; ++sidetIter){
     // take it - if
     // a) you have a detector element ... protection
     // b) the detector element is EC
     if ( (*sidetIter) && (*sidetIter)->isEndcap() ){
        // get the identifier & calculate current layer and current disk from it
        Identifier    currentId((*sidetIter)->identify());
        currentring  = m_pixIdHelper->layer_disk(currentId);
        if (not m_layerIndicesEndcap.empty() and std::find(m_layerIndicesEndcap.begin(), m_layerIndicesEndcap.end(), currentring) == m_layerIndicesEndcap.end())
          continue;
 
        double currentZ = (*sidetIter)->center().z();
        currentdisk = (unsigned int)m_pixIdHelper->eta_module(currentId);
        currentlayer = currentdisk;
        for (unsigned int i = 0; i < currentring; i++) {
          if (not m_layerIndicesEndcap.empty() and
            std::find(m_layerIndicesEndcap.begin(), m_layerIndicesEndcap.end(), i)==m_layerIndicesEndcap.end() ) continue;
          if (m_siMgr->numerology().useDiskLayer(i)) {
            currentlayer+=m_siMgr->numerology().numDisksForLayer(i);
          }
        }
        // parse all z positions for the mean value of the discs
        currentlayer += currentZ > 0. ? endcapLayers : 0;
 
        // increase the counter of endcap modules
        endcapModules++;
 
        takeSmallerBigger(discZmin[currentlayer],discZmax[currentlayer],currentZ);
 
        // set the disc Rmin / Rmax
        double currentRmin = (*sidetIter)->rMin();
        double currentRmax = (*sidetIter)->rMax();
 
        // the current phi
        double currentPhi = (*sidetIter)->center().phi();
        takeSmaller(discRmin[currentlayer],currentRmin);
        takeBigger( discRmax[currentlayer],currentRmax);
 
        //fill the number of phi sectors for the different rings
        if (discPhiSectors[currentlayer]<0){
          ATH_MSG_VERBOSE("Pre-processing Elements from Disk/Layer (id from idHelper): " << currentring << "/" << currentdisk );
          // get the number of phi sectors
          unsigned int phiSectorsRing = m_siMgr->numerology().numPhiModulesForLayerDisk(currentring, currentdisk);
          ATH_MSG_VERBOSE("--> has " << phiSectorsRing << " phi sectors");
          discPhiSectors[currentlayer]=phiSectorsRing;
        }
//         we take the phi / r binning only from the closer to IP module
        // take phi-min and phimax
        takeSmaller(discPhiMin[currentlayer],currentPhi);
        takeBigger(discPhiMax[currentlayer],currentPhi);
 
        const InDetDD::SiDetectorElement* detElement = (*sidetIter);
        // get the center position
        const Amg::Vector3D& orderPosition = detElement->center();
        // register the chosen side in the object array
        // Something like
        // std::shared_ptr<Trk::Surface>  =
        // std::make_shared<Trk::Surface>(detElement)) could be fine
        //
        // As things are now
        // 1) Notice that basically we couple the DetElement owned
        // surface to the Tracking Geometry passing a no-op deleter
        // (no delete happens) to the shared_ptr(SharedObject is
        // typedef of shared_ptr)
        // 2) The const_cast here make the
        // code non MT safe. For now we handle this by being careful
        // on lifetimes and non-re-entrant TG construction.
        std::shared_ptr<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(&(detElement->surface())),
                                                      Trk::do_not_delete<Trk::Surface>);
        Trk::SurfaceOrderPosition surfaceOrder(sharedSurface, orderPosition);
        discSurfaces[currentlayer].push_back(std::move(surfaceOrder));
 
     } else if (!(*sidetIter))
        ATH_MSG_WARNING("nullptr to Endcap module given by SCT_DetectorManager! Please check db & dict.xml");
  } // DetElement loop
 
  ATH_MSG_VERBOSE("Estimating the average z position and the radius for each disk.");
  // get the average z-position per layer & estimate thes thickness
  for (unsigned int iec=0; iec<2*endcapLayers; ++iec){
    // average it out
    discZpos[iec]        = 0.5 * (discZmin[iec] + discZmax[iec]);
    discThickness[iec]   = std::abs(discZmax[iec]-discZmin[iec]);
    // make the map z / index
    discZposLayerIndex.insert(std::make_pair(discZpos[iec],iec));
  }
 
  // [-B-] ------------------------ Construction of the layers -----------------------------------
  // construct the layers
  auto discLayers = std::make_unique<std::vector< Trk::DiscLayer*> >();
  std::vector<double>::iterator discZposIter = discZpos.begin();
  int discCounter = 0;
 
  for ( ; discZposIter != discZpos.end(); ++discZposIter){
    // dynamic estimation 1: estimate the layer thickness dynamically
    double thickness = discThickness[discCounter]+m_endcapEnvelope;
 
    // screen output
    ATH_MSG_DEBUG( "Building a DiscLayer with single R sectors. " );
    ATH_MSG_DEBUG( "  -> At Z - Position      :  " << discZpos[discCounter] );
    ATH_MSG_DEBUG( "  -> With Thickness       :  " << thickness   << " i- ncludes envelope tolerance : " << m_endcapEnvelope );
    ATH_MSG_DEBUG( "  -> With Rmin/Rmax (est) :  " << discRmin[discCounter] << " / " << discRmax[discCounter] );
 
    // prepare the binned array, it can be with one to several rings
    std::unique_ptr<Trk::BinnedArray<Trk::Surface>> currentBinnedArray = nullptr;
 
    double halfPhiStep = M_PI/discPhiSectors[discCounter];
    // protection in case phi value was fluctuating around 0 or M_PI in parsing
    if (std::abs(discPhiMin[discCounter]+discPhiMax[discCounter])< halfPhiStep && std::abs(discPhiMin[discCounter]) < 0.5*halfPhiStep ){
      ATH_MSG_VERBOSE("Detected module fluctuation around +/- M_PI, correcting for it.");
      ATH_MSG_VERBOSE("    [0 - ] min phi / max phi detected  : "  << discPhiMin[discCounter] << " / " <<discPhiMax[discCounter]);
      discPhiMin[discCounter] += 2*halfPhiStep;
    }
 
    // prepare min phi and max phi & eventually a sub stepvalue
    ATH_MSG_VERBOSE("    [1 - ] min phi / max phi detected  : " << discPhiMin[discCounter] << " / " << discPhiMax[discCounter] );
    double minPhiCorrected = discPhiMin[discCounter]-halfPhiStep;
    double maxPhiCorrected = discPhiMax[discCounter]+halfPhiStep;
    // catch if the minPhi falls below M_PI
    if (minPhiCorrected < -M_PI){
      minPhiCorrected += 2*halfPhiStep;
      maxPhiCorrected += 2*halfPhiStep;
    }
 
    ATH_MSG_VERBOSE("    min phi / max phi corrected : " << minPhiCorrected << " / " << maxPhiCorrected );
    ATH_MSG_VERBOSE("Constructing a one-dimensional BinnedArray with phiMin / phiMax (bins) = "
                     << minPhiCorrected << " / " << maxPhiCorrected
                     << " (" << discPhiSectors[discCounter] << ")");
 
    auto currentBinUtility = Trk::BinUtility(discPhiSectors[discCounter],
                                             minPhiCorrected,
                                             maxPhiCorrected,
                                             Trk::closed,
                                             Trk::binPhi);
 
    // a one-dimensional BinnedArray is sufficient
    currentBinnedArray = std::make_unique<Trk::BinnedArray1D<Trk::Surface>>(discSurfaces[discCounter],currentBinUtility);
 
    int discSurfacesNum = (discSurfaces[discCounter]).size();
    ATH_MSG_DEBUG( "Constructed BinnedArray for DiscLayer with "<< discSurfacesNum << " SubSurfaces." );
 
    // always run the geometry validation to catch flaws
 
    // checking for :
    //   - empty surface bins
    //   - doubly filled bins
    std::map< Trk::Surface*,Amg::Vector3D > uniqueSurfaceMap;
    std::map< Trk::Surface*,Amg::Vector3D >::iterator usmIter = uniqueSurfaceMap.end();
    // check the registered surfaces in the binned array
    std::span<Trk::Surface * const> arraySurfaces = currentBinnedArray->arrayObjects();
    size_t dsumCheckSurfaces = 0;
    double lastPhi = 0.;
    for (const auto & asurfIter : arraySurfaces){
      if ( asurfIter ) {
        ++dsumCheckSurfaces;
        usmIter = uniqueSurfaceMap.find(asurfIter);
        lastPhi = asurfIter->center().phi();
        if ( usmIter != uniqueSurfaceMap.end() )
          ATH_MSG_WARNING("Non-unique surface found with eta/phi = " << asurfIter->center().eta() << " / " << asurfIter->center().phi());
        else uniqueSurfaceMap[asurfIter] = asurfIter->center();
      } else
        ATH_MSG_WARNING("Zero-pointer in array detected in this ring, last valid phi value was = " << lastPhi);
    }
    sumCheckEndcapModules +=  dsumCheckSurfaces;
 
    ATH_MSG_DEBUG( "  -> With Rmin/Rmax :  " << discRmin[discCounter] << " / " << discRmax[discCounter] );
 
    // get the layer material from the helper method
    const Trk::LayerMaterialProperties& layerMaterial = endcapLayerMaterial(discRmin[discCounter],discRmax[discCounter]);
 
    // position & bounds of the active Layer
    Amg::Transform3D  activeLayerTransform;
    activeLayerTransform = Amg::Translation3D(0.,0.,discZpos[discCounter]);
 
    auto activeLayerBounds    = std::make_shared<Trk::DiscBounds>(discRmin[discCounter],discRmax[discCounter]);
    std::vector<Trk::BinUtility> binUtils = std::vector<Trk::BinUtility>();
    // prepare the right overlap descriptor
    auto olDescriptor = std::make_unique<InDet::DiscOverlapDescriptor>(currentBinnedArray.get(), binUtils, true);
    std::span<Trk::Surface * const> layerSurfaces     = currentBinnedArray->arrayObjects();
    // layer creation; deletes currentBinnedArray in baseclass 'Layer' upon destruction
    // activeLayerTransform deleted in 'Surface' baseclass
    Trk::DiscLayer* activeLayer = new Trk::DiscLayer(
        activeLayerTransform, std::move(activeLayerBounds), std::move(currentBinnedArray),
        layerMaterial, thickness, std::move(olDescriptor));
    // register the layer to the surfaces --- if necessary to the other sie as
    // well
    registerSurfacesToLayer(layerSurfaces,*activeLayer);
    discLayers->push_back(activeLayer);
    // increase the disc counter by one
    ++discCounter;
  }
 
  ATH_MSG_DEBUG( endcapModules << " Endcap Modules parsed for Disc Layer dimensions." );
  ATH_MSG_DEBUG( sumCheckEndcapModules << " Endcap Modules filled in Disc Layer Arrays." );
  if ( endcapModules-sumCheckEndcapModules )
    ATH_MSG_WARNING( endcapModules-sumCheckEndcapModules << " Modules not registered properly in binned array." );
 
 
  // sort the vector
  Trk::DiscLayerSorterZ zSorter;
  std::vector<Trk::DiscLayer*>::iterator sortIter = discLayers->begin();
  std::vector<Trk::DiscLayer*>::iterator sortEnd   = discLayers->end();
  std::sort(sortIter, sortEnd, zSorter);
 
  // if there are additional layers to be built - never build for the DBM loop
  if (!m_endcapAdditionalLayerPosZ.empty()){
    // sort also the additional layer z positions
    auto addLayerIter     = m_endcapAdditionalLayerPosZ.begin();
    auto addLayerIterEnd  = m_endcapAdditionalLayerPosZ.end();
    auto addLayerTypeIter = m_endcapAdditionalLayerType.begin();
    // reassign the iterators
    sortIter = discLayers->begin();
    sortEnd   = discLayers->end();
    // get the last rmin / rmax
    double lastRmin = 0.;
    double lastRmax = 0.;
    // build the additional layers -------------------------------------------
    for ( ; sortIter != sortEnd || addLayerIter != addLayerIterEnd; ){
      // cache befor last parameters are overwritten
      double layerRmin       = lastRmin;
      double layerRmax       = lastRmax;
      double layerZposition   = 0.;
      // check if the z-position is smaller than the
      if ( sortIter != sortEnd){
        // get the current z position to guarantee a symmetrical setup
        layerZposition = (*sortIter)->surfaceRepresentation().center().z();
        // get the bounds for the rMin / rMax setting
        const Trk::DiscBounds* currentBounds = dynamic_cast<const Trk::DiscBounds*>(&((*sortIter)->surfaceRepresentation().bounds()));
        lastRmin = currentBounds ? currentBounds->rMin() : 0.;
        lastRmax = currentBounds ? currentBounds->rMax() : 0.;
        ++sortIter;
      }
      if ( addLayerIter != addLayerIterEnd){
        // symmetric setup around 0.
        double rMin = layerZposition > 0. ? layerRmin : lastRmin;
        double rMax = layerZposition > 0. ? layerRmax : lastRmax;
        // the passive layer
        Trk::DiscLayer* passiveLayer = nullptr;
        // passive layer creation
        Amg::Transform3D passiveDiscTransf = Amg::Transform3D(Amg::Translation3D(0., 0., *addLayerIter));
        if (*addLayerTypeIter) {
          ATH_MSG_DEBUG("Building an additional DiscLayer w/o sensitive modules at");
          // create the material and the passive layer
          const Trk::LayerMaterialProperties& passiveLayerMaterial = endcapLayerMaterial(rMin, rMax);
          passiveLayer = new Trk::DiscLayer(passiveDiscTransf,
                                            std::make_shared<Trk::DiscBounds>(rMin, rMax),
                                            passiveLayerMaterial,
                                            1. * Gaudi::Units::mm);
        } else {
          passiveLayer = new Trk::DiscLayer(passiveDiscTransf,
                                            std::make_shared<Trk::DiscBounds>(rMin, rMax),
                                            nullptr);
        }
        ATH_MSG_DEBUG( "  -> At Z - Position       :  " << *addLayerIter );
        ATH_MSG_DEBUG( "  -> With Rmin/Rmax (corr) :  " << rMin << " / " << rMax );
 
        // increase the iterator and push back the new layer
        ++addLayerIter;
        discLayers->push_back(passiveLayer);
      }
    } // the additional layers are build ------------------------------------
 
    // another round of sorting needed after adding the passive layers
    sortIter = discLayers->begin();
    sortEnd   = discLayers->end();
    std::sort(sortIter, sortEnd, zSorter);
  }
 
  ATH_MSG_DEBUG("Returning: " << discLayers->size() << " disk-like layers to the volume builder");
  for (const auto& dl : (*discLayers)){
    ATH_MSG_VERBOSE(" ----> Disk layer located at : " << dl->surfaceRepresentation().center().z());
  }
 
  return discLayers;
}

cylindricalLayersImpl()

std::unique_ptr< const std::vector< Trk::CylinderLayer * > > InDet::SiLayerBuilderImpl::cylindricalLayersImpl ( const InDetDD::SiDetectorElementCollection & siDetElementCollection ) const

protected

Definition at line 850 of file SiLayerBuilderImpl.cxx.

{
  // sanity check for ID Helper
  if (!m_pixIdHelper && !m_sctIdHelper){
    ATH_MSG_ERROR("Neither Pixel nor SCT Detector Manager or ID Helper could be retrieved - giving up.");
    return nullptr;
  }
 
  // take the numerology
  const InDetDD::SiNumerology& siNumerology = m_siMgr->numerology();
 
  // pre-set parameters for the run
  size_t barrelLayers = 0;
  // save way to estimate the number of barrel layers : they can be deactivated hence the useLayer(i) check
  for (int i = 0; i < siNumerology.numLayers(); i++)
       if (siNumerology.useLayer(i)) barrelLayers++;
 
  if (not m_layerIndicesBarrel.empty())
    barrelLayers = m_layerIndicesBarrel.size();
 
  // screen output
  ATH_MSG_DEBUG( "Configured to build " << barrelLayers << " (active) barrel layers (out of " << siNumerology.numLayers() << " )" );
  if (!m_barrelAdditionalLayerR.empty())
      ATH_MSG_DEBUG( "Additionally " <<  m_barrelAdditionalLayerR.size() << " material layers will be built.");
 
  // for barrels (the statistics for ordering the modules)
  std::vector<double>                                               layerRadius(barrelLayers,0.);
  std::vector<double>                                               layerRmin(barrelLayers,10e10);
  std::vector<double>                                               layerRmax(barrelLayers,0.);
  std::vector<double>                                               layerThickness(barrelLayers,0.);
  std::vector<double>                                               layerMinZ(barrelLayers,0.);
  std::vector<double>                                               layerMaxZ(barrelLayers,0.);
  std::vector<double>                                               layerHalfLength(barrelLayers,0.);
  std::vector<double>                                               layerMinPhi(barrelLayers,0.);
  std::vector<double>                                               layerMaxPhi(barrelLayers,0.);
  std::vector<size_t>                                               layerPhiSectors(barrelLayers,0);
  std::vector<size_t>                                               layerZsectors(barrelLayers,0);
  std::vector< std::vector<float> >                                 layerZboundaries(barrelLayers, std::vector<float>());
  std::vector< std::vector< Trk::SurfaceOrderPosition > >           layerSurfaces(barrelLayers, std::vector< Trk::SurfaceOrderPosition >());
 
  // cache needed
  double minHalflengthZ         = 10e10;
  double maxHalflengthZ         = 0;
  size_t sumCheckBarrelModules  = 0;
  size_t barrelModules          = 0;
 
  // [-A-] ------------------------ LOOP over Detector Elements of sensitive layers -----------------------------------
  // iterate over the detector elements for layer dimension, etc.
  const InDetDD::SiDetectorElementCollection::const_iterator sidetBegin = siDetElementCollection.begin();
  const  InDetDD::SiDetectorElementCollection::const_iterator sidetEnd = siDetElementCollection.end();
  InDetDD::SiDetectorElementCollection::const_iterator sidetIter = sidetBegin;
  for (; sidetIter != sidetEnd; ++sidetIter){
     // Barrel check
     if ((*sidetIter) && (*sidetIter)->isBarrel()){
       // get the identifier
       Identifier    currentId((*sidetIter)->identify());
       int currentlayerIndex = m_pixIdHelper ? m_pixIdHelper->layer_disk(currentId) : m_sctIdHelper->layer_disk(currentId);
       if (not m_layerIndicesBarrel.empty()) {
         if (std::find(m_layerIndicesBarrel.begin(), m_layerIndicesBarrel.end(), currentlayerIndex) == m_layerIndicesBarrel.end())
           continue;
       }
       // unit test
       ++barrelModules;
       //skip the layer if it is chosen to be switched off
       if ( !m_siMgr->numerology().useLayer(currentlayerIndex) ) continue;
       // get layer index considering possible offset
       int currentlayer = m_layerIndicesBarrel.empty() ?
         currentlayerIndex : (currentlayerIndex-m_layerIndicesBarrel.value().at(0));
       // (A) Determination of phi / eta sectors  ---------------------------------------------------
       // only do the exercise if it hasn't been done already
       if (layerPhiSectors[currentlayer] == 0){
          ATH_MSG_VERBOSE("Pre-processing Elements from Layer (id from idHelper): " << currentlayer );
          // set number of phiSectors
          layerPhiSectors[currentlayer] = m_siMgr->numerology().numPhiModulesForLayer(currentlayerIndex);
          // set number of etaSectors
          layerZsectors[currentlayer] = m_siMgr->numerology().numEtaModulesForLayer(currentlayerIndex);
          // get the HalfLength of the Layer
          const InDetDD::SiDetectorElement* countPtr = (*sidetIter);
          // needed for the complex z binning if activated
          double lastModuleZ = 0.;
          std::vector<float> zboundaries;
          zboundaries.reserve(layerZsectors[currentlayer]+1);
          // walk all along to negative eta
          while ((countPtr->prevInEta()))
                 countPtr = countPtr->prevInEta();
           layerMinZ[currentlayer] = countPtr->center().z() - 0.5*std::abs(countPtr->length());
           zboundaries.push_back(layerMinZ[currentlayer]);
           lastModuleZ   = countPtr->center().z();
           // register the layer minZ into the zboundaries
           // now walk all along to positive eta
           while ((countPtr->nextInEta())) {
                  countPtr = countPtr->nextInEta();
                  // for complex binning
                  double currentModuleZ   = countPtr->center().z();
                  double currentZboundary = 0.5*(lastModuleZ+currentModuleZ);
                  zboundaries.push_back(currentZboundary);
                  lastModuleZ   = currentModuleZ;
           }
           layerMaxZ[currentlayer] = std::abs(countPtr->center().z()) + 0.5*std::abs(countPtr->length());
           zboundaries.push_back(layerMaxZ[currentlayer]);
 
           // complex z binning mode
           layerZboundaries[currentlayer] = std::move(zboundaries);
           // chose which one to register for the split mode (SLHC)
           layerHalfLength[currentlayer] =  layerMinZ[currentlayer]*layerMinZ[currentlayer] > layerMaxZ[currentlayer]*layerMaxZ[currentlayer] ?
               std::abs(layerMinZ[currentlayer]) : layerMaxZ[currentlayer];
           // get the haflength of the layer
           takeSmaller( minHalflengthZ, layerHalfLength[currentlayer]);
           takeBigger( maxHalflengthZ, layerHalfLength[currentlayer]);
           ATH_MSG_VERBOSE("      -> Determined Layer z range with  : " << layerMinZ[currentlayer] << " / " << layerMaxZ[currentlayer] );
           ATH_MSG_VERBOSE("      -> Symmetric half length taken    : " << layerHalfLength[currentlayer]);
       }
 
       // (B) Determination of the radius ------------------------------------------------
       // getting inner module
       const InDetDD::SiDetectorElement* otherSide = (*sidetIter)->otherSide();
       // take the maximum layer radius
       double currentR    = (*sidetIter)->center().perp();
       double currentRmax = (*sidetIter)->rMax();
       double currentRmin = (*sidetIter)->rMin();
       layerRadius[currentlayer]  = (currentR > layerRadius[currentlayer]) ? currentR : layerRadius[currentlayer];
       if (otherSide){
           takeBigger( currentRmax, (otherSide)->rMax() );
           takeSmaller( currentRmin, (otherSide)->rMin() );
       }
       takeSmaller( layerRmin[currentlayer], currentRmin );
       takeBigger(  layerRmax[currentlayer], currentRmax );
 
       // fill the Surface vector
       Amg::Vector3D orderPosition((*sidetIter)->center());
       double currentPhi = orderPosition.phi();
             takeSmaller( layerMinPhi[currentlayer], currentPhi);
       takeBigger( layerMaxPhi[currentlayer], currentPhi);
 
       // decide which one to register on the Radius: always the one with smaller radius
       bool takeIt =  (!otherSide || (*sidetIter)->center().perp() < otherSide->center().perp() );
       const Trk::Surface* moduleSurface = takeIt ? (&((*sidetIter)->surface())) : (&(otherSide->surface()));
 
       // register the module surface
       // std::shared_ptr<Trk::Surface>  =
       // std::make_shared<Trk::Surface>(.... some det element)) could be fine
       //
       // As things are now
       // 1) Notice that basically we couple the DetElement owned
       // surface to the Tracking Geometry passing a no-op deleter
       // (no delete happens) to the shared_ptr(SharedObject is
       // typedef of shared_ptr)
       // 2) The const_cast here make the
       // code non MT safe. For now we handle this by being careful
       // on lifetimes and non-re-entrant TG construction.
       std::shared_ptr<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(moduleSurface),
                                                     Trk::do_not_delete<Trk::Surface>);
 
       Trk::SurfaceOrderPosition surfaceOrder(sharedSurface, orderPosition);
       if (takeIt) (layerSurfaces[currentlayer]).push_back(std::move(surfaceOrder));
 
     } else if (!(*sidetIter)) // barrel check and screen output
        ATH_MSG_WARNING("nullptr to Barrel module given by SiDetectorManager! Please check db & dict.xml");
 
  } // SiDet Loop
 
  // --------------------------- enf of LOOP over Detector Elements of sensitive layers ----------------------------------
 
  // [-B-] ------------------------ Construction of the layers -----------------------------------
  // [-B-1] construct the detection layers
  std::vector< Trk::CylinderLayer* > cylinderDetectionLayers;
  int layerCounter          = 0;
  double currentLayerExtend = 0.;
 
  // construct detection layers
  for (auto& layerRadiusIter : layerRadius) {
 
      Trk::CylinderLayer* activeLayer   = nullptr;
      // non-equidistant binning used ? auto-detection
      bool nonEquidistantBinning = false;
      {
          // calculate the average bin size
          const double averageBinSize = (layerMaxZ[layerCounter]-layerMinZ[layerCounter])/(layerZsectors[layerCounter]);
          const double inv_averageBinSize2 = 1. / (averageBinSize*averageBinSize);
          // loop over the boundaries and check if theyare outside the tolerance
          auto bIter  = layerZboundaries[layerCounter].begin();
          auto bIterE = layerZboundaries[layerCounter].end();
          for ( ++bIter; bIter != bIterE; ++bIter ){
              float cZ = (*bIter);
              float pZ = (*(bIter-1));
              nonEquidistantBinning =  (cZ-pZ)*(cZ-pZ)*inv_averageBinSize2 < (1.-m_barrelEdbTolerance) *(1.-m_barrelEdbTolerance);
              if (nonEquidistantBinning){
                  ATH_MSG_VERBOSE("Non-equidistant binning for (Silicon) Surfaces on this layer with radius " << layerRadiusIter << " detected. ");
                  ATH_MSG_VERBOSE("Difference " << (cZ-pZ)/averageBinSize << " at a allowed tolerance of : " << m_barrelEdbTolerance );
                  break;
              }
          }
      }
 
      //(1) the detecting layer : sensitive modules --------------------------------------------------------------------
      // create the BinKeyUtility - the phi binning is identical
      double halfPhiStep = M_PI/layerPhiSectors[layerCounter];
      // protection in case phi value was fluctuating around 0 or M_PI in parsing
      if (std::abs(layerMinPhi[layerCounter]+layerMaxPhi[layerCounter])< halfPhiStep && std::abs(M_PI+layerMinPhi[layerCounter]) < 0.5*halfPhiStep ){
          ATH_MSG_VERBOSE("Detected module fluctuation around +/- M_PI, correcting for it.");
          ATH_MSG_VERBOSE("    min phi / max phi detected  : "  << layerMinPhi[layerCounter] << " / " << layerMaxPhi[layerCounter] );
          layerMinPhi[layerCounter] += 2*halfPhiStep;
      }
      // now prepare the phi values
      ATH_MSG_VERBOSE("Preparing the Phi-binning for   : " << layerPhiSectors[layerCounter] << " sectors.");
      ATH_MSG_VERBOSE("    min phi / max phi detected  : " << layerMinPhi[layerCounter] << " / " << layerMaxPhi[layerCounter] );
      double minPhiCorrected = layerMinPhi[layerCounter]-halfPhiStep;
      double maxPhiCorrected = layerMaxPhi[layerCounter]+halfPhiStep;
      // catch if the minPhi falls below M_PI
      if (minPhiCorrected < -M_PI){
          minPhiCorrected += 2*halfPhiStep;
          maxPhiCorrected += 2*halfPhiStep;
      }
      ATH_MSG_VERBOSE("    min phi / max phi corrected : " << minPhiCorrected << " / " << maxPhiCorrected );
 
 
      auto currentBinUtility  = Trk::BinUtility(layerPhiSectors[layerCounter],
                                                minPhiCorrected,
                                                maxPhiCorrected,
                                                Trk::closed, Trk::binPhi);
      if (nonEquidistantBinning)
          currentBinUtility += Trk::BinUtility(layerZboundaries[layerCounter],
                                               Trk::open,
                                               Trk::binZ);
      else
          currentBinUtility += Trk::BinUtility(layerZsectors[layerCounter],
                                               layerMinZ[layerCounter],
                                               layerMaxZ[layerCounter],
                                               Trk::open,
                                               Trk::binZ);
      // creating the binned array output
      ATH_MSG_VERBOSE("Creating the binned array for the sensitive detector elements with BinUtility :");
      ATH_MSG_VERBOSE( currentBinUtility );
      // the binned array for the senstive surfaces to be built
      auto currentBinnedArray =
          std::make_unique<Trk::BinnedArray2D<Trk::Surface>>(
              layerSurfaces[layerCounter], currentBinUtility);
      // unit test for sub surface ordering
      std::span<Trk::Surface * const> arraySurfaces = currentBinnedArray->arrayObjects();
 
      if (m_runGeometryValidation){
         // checking for :
         //   - empty surface bins
         //   - doubly filled bins
         std::map< const Trk::Surface*,Amg::Vector3D > uniqueSurfaceMap;
         auto usmIter = uniqueSurfaceMap.end();
         // ------- iterate
         auto asurfIter = arraySurfaces.begin();
         auto asurfIterEnd = arraySurfaces.end();
         for ( ; asurfIter != asurfIterEnd; ++asurfIter){
             if ( (*asurfIter) ) {
                ++sumCheckBarrelModules;
                usmIter = uniqueSurfaceMap.find(*asurfIter);
                if ( usmIter != uniqueSurfaceMap.end() )
                    ATH_MSG_WARNING("Non-unique surface found with eta/phi = " << (*asurfIter)->center().eta() << " / " << (*asurfIter)->center().phi());
                else uniqueSurfaceMap[(*asurfIter)] = (*asurfIter)->center();
               }
               else
               ATH_MSG_WARNING("Null surface defined in BinUtility ArraySurfaces vector");
         }
      }
 
      // dynamic layer extend
      currentLayerExtend = layerHalfLength[layerCounter];
 
      // dynamic layer extend determined by the sensitive layer dimensions
      layerRadius[layerCounter] = 0.5*(layerRmax[layerCounter] + layerRmin[layerCounter]);
      layerThickness[layerCounter] = layerRmax[layerCounter] - layerRmin[layerCounter];
 
      // create the material
      const Trk::LayerMaterialProperties& layerMaterial = barrelLayerMaterial(layerRadius[layerCounter], currentLayerExtend);
      double currentLayerThickness = layerThickness[layerCounter]+m_barrelEnvelope;
 
      // screen output
      ATH_MSG_DEBUG( "Construct BinnedArray for CylinderLayer with "<< (layerSurfaces[layerCounter]).size() << " SubSurfaces." );
      ATH_MSG_DEBUG( "Building a CylinderLayer with " << layerPhiSectors[layerCounter]
          << " / " <<   ( nonEquidistantBinning ? layerZboundaries[layerCounter].size() :  layerZsectors[layerCounter] ) << " phi/z bins. "   );
      ATH_MSG_DEBUG( "  -> With Radius     :  " << layerRadius[layerCounter]    );
      ATH_MSG_DEBUG( "  -> With Thickness  :  " << currentLayerThickness << " - includes envelope tolerance : " << m_barrelEnvelope );
      ATH_MSG_DEBUG( "  -> With Zmin/Zmax  :  " << -currentLayerExtend << " / " << currentLayerExtend );
 
      if ( nonEquidistantBinning && !layerZboundaries[layerCounter].empty() ){
          // overrule the min bin - with the min radius
          // do the output to screen
          double currentZ = -currentLayerExtend;
          msg(MSG::DEBUG) <<  "  -> Z binning at      :  ";
          for (size_t zbin = 0; zbin < layerZboundaries[layerCounter].size(); ++zbin) {
              currentZ += layerZboundaries[layerCounter][zbin];
              msg(MSG::DEBUG) << currentZ;
              if (zbin <  layerZboundaries[layerCounter].size()-1)
                 msg(MSG::DEBUG) << ", ";
          }
          msg(MSG::DEBUG) << endmsg;
      }
      // prepare the right overlap descriptor
      std::unique_ptr<Trk::OverlapDescriptor> olDescriptor = nullptr;
      if (m_pixelCase){
          olDescriptor = std::make_unique<InDet::PixelOverlapDescriptor>(m_addMoreSurfaces);
      }
      else {
        olDescriptor = std::make_unique<InDet::SCT_OverlapDescriptor>(m_addMoreSurfaces);
      }
 
      std::span<Trk::Surface * const> layerSurfaces     = currentBinnedArray->arrayObjects();
      // construct the layer (finally)
      activeLayer = new Trk::CylinderLayer(
          std::make_shared<Trk::CylinderBounds>(layerRadius[layerCounter],
                                  currentLayerExtend),
          std::move(currentBinnedArray), layerMaterial, currentLayerThickness,
          std::move(olDescriptor));
      // register the layer to the surfaces
      registerSurfacesToLayer(layerSurfaces,*activeLayer);
 
      // (3) register the layers
      cylinderDetectionLayers.push_back(activeLayer);
 
      // increase the layer counter --- it is built
      ++layerCounter;
 
  } // layer construction
  // --------------------------- enf of detection layer construction loop ----------------------------------
 
  ATH_MSG_DEBUG("Creating the final CylinderLayer collection with (potentially) additional layers.");
  std::unique_ptr<std::vector< Trk::CylinderLayer* > > cylinderLayers
    = dressCylinderLayers(cylinderDetectionLayers);
 
  // multiply the check number in case of SCT
  sumCheckBarrelModules *= (m_pixelCase) ? 1 : 2;
  ATH_MSG_DEBUG( barrelModules << " Barrel Modules parsed for Cylinder Layer dimenstions." );
  ATH_MSG_DEBUG( sumCheckBarrelModules << " Barrel Modules filled in Cylinder Layer Arrays." );
  if ( barrelModules-sumCheckBarrelModules )
     ATH_MSG_WARNING( barrelModules-sumCheckBarrelModules << " Modules not registered properly in binned array." );
 
  ATH_MSG_DEBUG("Returning " << cylinderLayers->size() << " cylinder layers.");
  return cylinderLayers;
}

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

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

dressCylinderLayers()

std::unique_ptr< std::vector< Trk::CylinderLayer * > > InDet::SiLayerBuilderImpl::dressCylinderLayers ( const std::vector< Trk::CylinderLayer * > & dLayers ) const

protected

helper method to construct barrel material

Definition at line 1189 of file SiLayerBuilderImpl.cxx.

                                                                                                       {
 
 
  auto cylinderLayers = std::make_unique<std::vector<Trk::CylinderLayer*> >();
  // --------------------------- start of additional layer construction loop
  // ------------------------------- for the additional layer
  if (!m_barrelAdditionalLayerR.empty()){
    auto cylLayerIter         = detectionLayers.begin();
    auto cylLayerIterEnd      = detectionLayers.end();
    auto addLayerIter         = m_barrelAdditionalLayerR.begin();
    auto addLayerIterEnd      = m_barrelAdditionalLayerR.end();
    auto addLayerTypeIter     = m_barrelAdditionalLayerType.begin();
    auto addLayerTypeIterEnd  = m_barrelAdditionalLayerType.end();
    double cylLayerExtend     = 0;
    for ( ; addLayerIter != addLayerIterEnd && addLayerTypeIter != addLayerTypeIterEnd; ) {
      // build the passive layer if it is smaller the current
      // cylLayerIter - or if it is the last one
      const bool lastLayer = (cylLayerIter == cylLayerIterEnd);
      if  ( lastLayer || (*addLayerIter) < (*cylLayerIter)->bounds().r() ) {
        //cppcheck-suppress derefInvalidIteratorRedundantCheck
        cylLayerExtend = lastLayer ? cylLayerExtend : (*cylLayerIter)->bounds().halflengthZ() ;
        if ((*addLayerTypeIter)) {
          ATH_MSG_DEBUG("[- M -] Building an additional CylinderLayer w/o "
                        "sensitive modules");
          // the material for the passive layer
          const Trk::LayerMaterialProperties& passiveLayerMaterial = barrelLayerMaterial(*addLayerIter, cylLayerExtend);
          // create the passive layer
          cylinderLayers->push_back(new Trk::CylinderLayer(std::make_shared<Trk::CylinderBounds>(*addLayerIter, cylLayerExtend),
              passiveLayerMaterial, 1. * Gaudi::Units::mm, nullptr, 0));
        } else {
          ATH_MSG_DEBUG("[- N -] Building an additional NavigationLayer for "
                        "volume dimension control");
          // create the passive layer
          cylinderLayers->push_back(new Trk::CylinderLayer(
            std::make_shared<Trk::CylinderBounds>(*addLayerIter, cylLayerExtend), nullptr));
        }
        ATH_MSG_DEBUG("  -> With Radius     :  " << *addLayerIter);
        // increase the additional layer radii
        ++addLayerIter;
        ++addLayerTypeIter;
        continue;
      }
      ATH_MSG_DEBUG("[- D -] Registering detection CylinderLayer");
      ATH_MSG_DEBUG("  -> With Radius     :  " << (*cylLayerIter)->bounds().r());
      cylinderLayers->push_back(*cylLayerIter);
      ++cylLayerIter;
    }
  } else
    for (const auto & cylLayerIter : detectionLayers ) {
      ATH_MSG_DEBUG("[- D -] Registering detection CylinderLayer");
      ATH_MSG_DEBUG( "  -> With Radius     :  " << cylLayerIter->bounds().r()   );
      cylinderLayers->push_back(cylLayerIter);
    }
  return cylinderLayers;
}

endcapLayerMaterial()

const Trk::BinnedLayerMaterial InDet::SiLayerBuilderImpl::endcapLayerMaterial ( double rMin, double rMax ) const

protected

Definition at line 1266 of file SiLayerBuilderImpl.cxx.

{
  // --------------- material estimation ----------------------------------------------------------------
  Trk::BinUtility layerBinUtilityR(m_endcapLayerBinsR,rMin,rMax,Trk::open, Trk::binR);
  if (m_endcapLayerBinsPhi!=1u){ // -- material with 2D binning
      Trk::BinUtility layerBinUtilityPhi(m_endcapLayerBinsPhi,-M_PI,M_PI,Trk::closed,Trk::binPhi);
      layerBinUtilityR += layerBinUtilityPhi;
  }
  //const auto layerMaterial = Trk::BinnedLayerMaterial(layerBinUtilityR);
  // --------------- material estimation ----------------------------------------------------------------
  return Trk::BinnedLayerMaterial(layerBinUtilityR);
}

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

finalize()

StatusCode InDet::SiLayerBuilderImpl::finalize ( )

overridevirtual

AlgTool finalize method.

Definition at line 68 of file SiLayerBuilderImpl.cxx.

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

initialize()

StatusCode InDet::SiLayerBuilderImpl::initialize ( )

overridevirtual

AlgTool initialize method.

Definition at line 34 of file SiLayerBuilderImpl.cxx.

{
    ATH_MSG_DEBUG( "initialize()" );
    // get Pixel Detector Description Manager
    if (m_pixelCase){
        const InDetDD::PixelDetectorManager* pixMgr = nullptr;
        if ((detStore()->retrieve(pixMgr, m_siMgrLocation)).isFailure()) {
            ATH_MSG_ERROR( "Could not get PixelDetectorManager '" << m_siMgrLocation << "', no layers for Pixel Detector will be built. " );
        } else {
            ATH_MSG_VERBOSE( "PixelDetectorManager retrieved with key '" << m_siMgrLocation <<"'." );
            // assign the detector manager to the silicon manager
            m_siMgr = pixMgr;
            if (detStore()->retrieve(m_pixIdHelper, "PixelID").isFailure())
                ATH_MSG_ERROR("Could not get Pixel ID helper");
        }
    } else {
        const InDetDD::SCT_DetectorManager* sctMgr = nullptr;
        if ((detStore()->retrieve(sctMgr, m_siMgrLocation)).isFailure()) {
            ATH_MSG_ERROR( "Could not get SCT_DetectorManager '" << m_siMgrLocation << "', no layers for SCT Detector will be built. " );
        } else {
            ATH_MSG_VERBOSE( "SCT_DetectorManager retrieved with key '" << m_siMgrLocation <<"'." );
            // assign the detector manager to the silicon manager
            m_siMgr = sctMgr;
            if (detStore()->retrieve(m_sctIdHelper, "SCT_ID").isFailure())
                ATH_MSG_ERROR("Could not get SCT ID helper");
        }
    }
    ATH_CHECK(m_SCT_ReadKey.initialize(!m_pixelCase));
    ATH_CHECK(m_PixelReadKey.initialize());
    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.

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.

registerSurfacesToLayer()

void InDet::SiLayerBuilderImpl::registerSurfacesToLayer ( std::span< Trk::Surface *const > & layerSurfaces, Trk::Layer & lay ) const

protected

Definition at line 1279 of file SiLayerBuilderImpl.cxx.

                         {
  if (!m_setLayerAssociation){
      return;
  }
 
  auto laySurfIter = layerSurfaces.begin();
  const auto laySurfIterEnd = layerSurfaces.end();
  // register the surfaces to the layer
  for (; laySurfIter != laySurfIterEnd; ++laySurfIter){
    if (*laySurfIter) {
      // register the current surface
      (**laySurfIter).associateLayer(lay);
      const InDetDD::SiDetectorElement* detElement
        = dynamic_cast<const InDetDD::SiDetectorElement*>((*laySurfIter)->associatedDetectorElement());
      // register the backsise if necessary
      const InDetDD::SiDetectorElement* otherSideElement = detElement ?  detElement->otherSide() : nullptr;
      const Trk::Surface* otherSideSurface = otherSideElement ? &(otherSideElement->surface()) : nullptr;
      if (otherSideSurface) {
        // Needs care for Athena MT
        // we bind again to the detElement owned surface
        (const_cast<Trk::Surface&>(*otherSideSurface)).associateLayer(lay);
      }
    }
  }
}

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 368 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 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

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 >, and AthCheckedComponent<::AthAlgTool >.

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 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_addMoreSurfaces

BooleanProperty InDet::SiLayerBuilderImpl::m_addMoreSurfaces {this, "AddMoreSurfaces", false}

protected

to add additional surfaces to the PixelOverlapDescriptor, SCT_OverlapDescriptor and DiscOverlapDescriptor (used for ITk specific case)

Definition at line 130 of file SiLayerBuilderImpl.h.

{this, "AddMoreSurfaces", false}; 

m_barrelAdditionalLayerR

DoubleArrayProperty InDet::SiLayerBuilderImpl::m_barrelAdditionalLayerR {this, "BarrelAdditionalLayerRadii", {} }

protected

Create an additional layer at these radii.

Definition at line 108 of file SiLayerBuilderImpl.h.

{this, "BarrelAdditionalLayerRadii", {} };         

m_barrelAdditionalLayerType

IntegerArrayProperty InDet::SiLayerBuilderImpl::m_barrelAdditionalLayerType {this, "BarrelAdditionalLayerType", {} }

protected

material layer 1 - navigation layer 0

Definition at line 109 of file SiLayerBuilderImpl.h.

{this, "BarrelAdditionalLayerType", {} };      

m_barrelEdbTolerance

DoubleProperty InDet::SiLayerBuilderImpl::m_barrelEdbTolerance {this, "BarrelEdbTolerance", 0.05}

protected

tolerance in percent how much the bin sizes can change

Definition at line 113 of file SiLayerBuilderImpl.h.

{this, "BarrelEdbTolerance", 0.05};             

m_barrelEnvelope

DoubleProperty InDet::SiLayerBuilderImpl::m_barrelEnvelope {this, "BarrelEnvelope", 0.1}

protected

envelope around rMin/rMax

Definition at line 112 of file SiLayerBuilderImpl.h.

{this, "BarrelEnvelope", 0.1};                 

m_barrelLayerBinsPhi

UnsignedIntegerProperty InDet::SiLayerBuilderImpl::m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}

protected

Barrel bins for the material in phi.

Definition at line 111 of file SiLayerBuilderImpl.h.

{this, "BarrelLayerBinsPhi", 1};             

m_barrelLayerBinsZ

UnsignedIntegerProperty InDet::SiLayerBuilderImpl::m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 100}

protected

Barrel bins for the material in z.

Definition at line 110 of file SiLayerBuilderImpl.h.

{this, "BarrelLayerBinsZ", 100};               

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_endcapAdditionalLayerPosZ

DoubleArrayProperty InDet::SiLayerBuilderImpl::m_endcapAdditionalLayerPosZ {this, "EndcapAdditionalLayerPositionsZ", {} }

protected

Create additional endcaps at these z positions.

Definition at line 116 of file SiLayerBuilderImpl.h.

{this, "EndcapAdditionalLayerPositionsZ", {} };      

m_endcapAdditionalLayerType

IntegerArrayProperty InDet::SiLayerBuilderImpl::m_endcapAdditionalLayerType {this,"EndcapAdditionalLayerType" , {} }

protected

material layer 1 - navigation layer 0 ( for volume adjustment )

Definition at line 117 of file SiLayerBuilderImpl.h.

{this,"EndcapAdditionalLayerType" , {} };      

m_endcapComplexRingBinning

BooleanProperty InDet::SiLayerBuilderImpl::m_endcapComplexRingBinning {this, "EndcapComplexRingBinning", true}

protected

make std::vector<R> rings, could be different for layers

Definition at line 121 of file SiLayerBuilderImpl.h.

{this, "EndcapComplexRingBinning", true};       

m_endcapEnvelope

DoubleProperty InDet::SiLayerBuilderImpl::m_endcapEnvelope {this, "EndcapEnvelope", 0.1}

protected

envelope around rMin/rMax

Definition at line 120 of file SiLayerBuilderImpl.h.

{this, "EndcapEnvelope", 0.1};                 

m_endcapLayerBinsPhi

UnsignedIntegerProperty InDet::SiLayerBuilderImpl::m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}

protected

Barrel bins for the material in phi.

Definition at line 119 of file SiLayerBuilderImpl.h.

{this, "EndcapLayerBinsPhi", 1};             

m_endcapLayerBinsR

UnsignedIntegerProperty InDet::SiLayerBuilderImpl::m_endcapLayerBinsR {this, "EndcapLayerBinsR", 100}

protected

Barrel bins for the material in r.

Definition at line 118 of file SiLayerBuilderImpl.h.

{this, "EndcapLayerBinsR", 100};               

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_identification

StringProperty InDet::SiLayerBuilderImpl::m_identification {this, "Identification", "Pixel"}

protected

string identification

Definition at line 123 of file SiLayerBuilderImpl.h.

{this, "Identification", "Pixel"};                  

m_layerIndicesBarrel

IntegerArrayProperty InDet::SiLayerBuilderImpl::m_layerIndicesBarrel {this, "LayerIndicesBarrel", {} }

protected

indices to be used for layer creation (used for ITk specific case)

Definition at line 127 of file SiLayerBuilderImpl.h.

{this, "LayerIndicesBarrel", {} }; 

m_layerIndicesEndcap

IntegerArrayProperty InDet::SiLayerBuilderImpl::m_layerIndicesEndcap {this, "LayerIndicesEndcap", {} }

protected

indices to be used for layer creation (used for ITk specific case)

Definition at line 128 of file SiLayerBuilderImpl.h.

{this, "LayerIndicesEndcap", {} }; 

m_pixelCase

BooleanProperty InDet::SiLayerBuilderImpl::m_pixelCase {this, "PixelCase", true}

protected

Common properties.

flag for pixel/sct

Definition at line 98 of file SiLayerBuilderImpl.h.

{this, "PixelCase", true}; 

m_PixelReadKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDet::SiLayerBuilderImpl::m_PixelReadKey {this, "PixelReadKey", "PixelDetectorElementCollection", "Key of output SiDetectorElementCollection for Pixel"}

protected

Definition at line 134 of file SiLayerBuilderImpl.h.

{this, "PixelReadKey", "PixelDetectorElementCollection", "Key of output SiDetectorElementCollection for Pixel"};

m_pixIdHelper

const PixelID* InDet::SiLayerBuilderImpl::m_pixIdHelper {}

protected

pixel Id Helper

Definition at line 101 of file SiLayerBuilderImpl.h.

{}; 

m_runGeometryValidation

BooleanProperty InDet::SiLayerBuilderImpl::m_runGeometryValidation {this, "GeometryValidation", true}

protected

run the validation of the geometry ( no empty bins)

Definition at line 125 of file SiLayerBuilderImpl.h.

{this, "GeometryValidation", true};           

m_SCT_ReadKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> InDet::SiLayerBuilderImpl::m_SCT_ReadKey {this, "SCT_ReadKey", "SCT_DetectorElementCollection", "Key of output SiDetectorElementCollection for SCT"}

protected

Definition at line 133 of file SiLayerBuilderImpl.h.

{this, "SCT_ReadKey", "SCT_DetectorElementCollection", "Key of output SiDetectorElementCollection for SCT"};

m_sctIdHelper

const SCT_ID* InDet::SiLayerBuilderImpl::m_sctIdHelper {}

protected

sct Id Helper

Definition at line 102 of file SiLayerBuilderImpl.h.

{}; 

m_setLayerAssociation

BooleanProperty InDet::SiLayerBuilderImpl::m_setLayerAssociation {this, "SetLayerAssociation", true}

protected

Set Layer Association.

Definition at line 104 of file SiLayerBuilderImpl.h.

{this, "SetLayerAssociation", true}; 

m_siMgr

const InDetDD::SiDetectorManager* InDet::SiLayerBuilderImpl::m_siMgr {}

protected

the Si Detector Manager

Definition at line 99 of file SiLayerBuilderImpl.h.

{}; 

m_siMgrLocation

StringProperty InDet::SiLayerBuilderImpl::m_siMgrLocation {this, "SiDetManagerLocation", "Pixel"}

protected

the location of the Pixel Manager

Definition at line 100 of file SiLayerBuilderImpl.h.

{this, "SiDetManagerLocation", "Pixel"}; 

m_useRingLayout

BooleanProperty InDet::SiLayerBuilderImpl::m_useRingLayout {this, "UseRingLayout", false}

protected

to enable creation of rings for ITk pixel geometry (used for ITk specific case)

Definition at line 129 of file SiLayerBuilderImpl.h.

{this, "UseRingLayout", false}; 

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• SiLayerBuilderImpl.h
• SiLayerBuilderImpl.cxx