#include <TRT_LayerBuilderImpl.h>

Inheritance diagram for InDet::TRT_LayerBuilderImpl:

Collaboration diagram for InDet::TRT_LayerBuilderImpl:

Public Member Functions
virtual	~TRT_LayerBuilderImpl ()=default
	Destructor. 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
	TRT_LayerBuilderImpl (const std::string &, const std::string &, const IInterface *)
	AlgTool style constructor. More...

std::unique_ptr< const std::vector< Trk::CylinderLayer * > >	cylindricalLayersImpl (const InDetDD::TRT_DetElementContainer *trtContainer) const

std::unique_ptr< const std::vector< Trk::DiscLayer * > >	discLayersImpl (const InDetDD::TRT_DetElementContainer *trtContainer) 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...

Protected Attributes
double	m_layerStrawRadius {2.0*Gaudi::Units::mm}
	straw radius More...

DoubleProperty	m_layerThickness {this, "LayerThickness", 0.1*Gaudi::Units::mm}
	modelled layer thickness More...

BooleanProperty	m_modelGeometry {this, "ModelLayersOnly", true}
	Build the geometry with model layers. More...

UnsignedIntegerProperty	m_modelBarrelLayers {this, "ModelBarrelLayers", 7}
	model barrel layers with material More...

UnsignedIntegerProperty	m_modelEndcapLayers {this, "ModelEndcapLayers", 14}
	model endcap layers with material More...

UnsignedIntegerProperty	m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 25}
	Bins for the Barrel material - in z. More...

UnsignedIntegerProperty	m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}
	Bins for the Barrel material - in phi. More...

UnsignedIntegerProperty	m_endcapLayerBinsR {this, "EndcapLayerBinsR", 25}
	Bins for the Endcap material - in r. More...

UnsignedIntegerProperty	m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}
	Bins for the Endcap material - in phi. More...

BooleanProperty	m_endcapConly {this, "EndcapConly", false}
	Only build the endcapC. More...

BooleanProperty	m_registerStraws {this, "RegisterStraws", false}
	register the straws More...

IntegerProperty	m_barrelSectorAtPiBoundary {this, "BarrelSectorAtPi", 16}
	this is the barrel Sector where +pi/-pi is within More...

StringProperty	m_identification {this, "Identification", "TRT"}
	string identification More...

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

Friends
class	TRT_VolumeBuilder
	Declare the TRT_VolumeBuilder as friend. More...

Detailed Description

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

Definition at line 50 of file TRT_LayerBuilderImpl.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

◆ ~TRT_LayerBuilderImpl()

virtual InDet::TRT_LayerBuilderImpl::~TRT_LayerBuilderImpl ( )

virtualdefault

Destructor.

◆ TRT_LayerBuilderImpl()

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

protected

AlgTool style constructor.

Definition at line 58 of file TRT_LayerBuilderImpl.cxx.

                                                                                                            :
   AthAlgTool(t,n,p)
 {
 }

Member Function Documentation

◆ cylindricalLayersImpl()

std::unique_ptr< const std::vector< Trk::CylinderLayer * > > InDet::TRT_LayerBuilderImpl::cylindricalLayersImpl ( const InDetDD::TRT_DetElementContainer * trtContainer ) const

protected

Definition at line 65 of file TRT_LayerBuilderImpl.cxx.

                                                                                                         {
   ATH_MSG_DEBUG( "Building cylindrical layers for the TRT " );
   PtrVectorWrapper<Trk::CylinderLayer> barrelLayers;
  
   // get Numerology and Id HElper
   const InDetDD::TRT_Numerology* trtNums = trtContainer->getTRTNumerology();
  
   // get the TRT ID Helper
   const TRT_ID* trtIdHelper = nullptr;
   if (detStore()->retrieve(trtIdHelper, "TRT_ID").isFailure()) {
     ATH_MSG_ERROR("Could not get TRT ID helper");
     return nullptr;
   }
  
   int    nBarrelRings  = trtNums->getNBarrelRings();
   int    nBarrelPhiSectors = trtNums->getNBarrelPhi();
   double layerPhiStep      = 2*M_PI/nBarrelPhiSectors;
  
   int nTotalBarrelLayers = 0;
  
   // get the overall dimensions
   double rMin = 10e10;
   double rMax = 0.;
  
   double layerZmax = 0.;
   double layerZmin = 10e10;
  
   // pre-loop for overall layer numbers & some ordering ---------------------------------------
   for (int ring=0; ring < nBarrelRings; ring++) {
     // the number of barrel layers
     int nBarrelLayers = trtNums->getNBarrelLayers(ring);
     nTotalBarrelLayers += nBarrelLayers;
     // loop over layers
     for (int layer=0; layer < nBarrelLayers; layer++){
       for (int phisec=0; phisec <nBarrelPhiSectors; ++phisec)
         {
           for (int iposneg=0; iposneg<2; ++iposneg){
             // get the element
             const InDetDD::TRT_BarrelElement* trtbar = trtContainer->getBarrelDetElement(iposneg, ring, phisec, layer); // TODO share this line
  
             // get overall dimensions only one time
             const Trk::PlaneSurface*    elementSurface = dynamic_cast<const Trk::PlaneSurface*>(&(trtbar->surface()));
             if (!elementSurface) {
               ATH_MSG_WARNING( "elementSurface: dynamic_cast to Trk::PlaneSurface failed - skipping ... ring/layer/phisec/iposneg = " << ring << "/" << layer << "/" << phisec << "/" << iposneg );
               continue;
             }
             const Trk::RectangleBounds* elementBounds  = dynamic_cast<const Trk::RectangleBounds*>(&(trtbar->bounds()));
             if (!elementBounds) {
               ATH_MSG_WARNING( "elementBounds: dynamic_cast to Trk::RectangleBounds failed - skipping ... ring/layer/phisec/iposneg = " << ring << "/" << layer << "/" << phisec << "/" << iposneg );
               continue;
             }
             double elementZcenter = (elementSurface->center()).z();
             double elementZmin    = std::abs(elementZcenter - elementBounds->halflengthY());
             double elementZmax    = std::abs(elementZcenter + elementBounds->halflengthY());
             // take what you need
             takeSmaller(layerZmin, elementZmin); takeBigger(layerZmax, elementZmax);
             // get the radial dimensions
             double currentR = trtbar->center().perp();
             takeSmallerBigger(rMin,rMax,currentR);
           }
         }
     }
   }
  
   if (nTotalBarrelLayers==0) {
     ATH_MSG_WARNING( "nTotalBarrelLayers = 0 ... aborting and returning 0 !" );
     return nullptr;
   }
  
   // calculate delta(R) steps and delta(R)
   double rDiff           = std::abs(rMax-rMin);
   double rStep           = rDiff/(m_modelBarrelLayers+1);
   double layerHalflength = layerZmax;
  
   // prepare the material
   if ( std::abs(rDiff) <= 0.1 ) {
     return nullptr;
   }
  
   //  fix the positions where the layers are - these are used for the model geometry and the complex geometry ---------------
   std::vector<double> layerRadii;
   layerRadii.reserve(m_modelBarrelLayers);
   for (unsigned int ilay = 1; ilay <= m_modelBarrelLayers; ++ilay)
     layerRadii.push_back(rMin+ilay*rStep-0.5*m_layerThickness);
   // these are the layer iterators
   auto layerRadiusIter    = layerRadii.begin();
   auto layerRadiusIterEnd = layerRadii.end();
  
   // (A) model geometry section
   if (m_modelGeometry && !m_registerStraws){
  
     ATH_MSG_VERBOSE( " -> " << layerRadii.size() << " cylindrical barrel layers between " << rMin << " and " << rMax << " ( at step "<< rStep << " )");
  
     // create the layers
     for ( ; layerRadiusIter != layerRadiusIterEnd; ++layerRadiusIter ) {
       // ----- prepare the BinnedLayerMaterial -----------------------------------------------------
       Trk::BinnedLayerMaterial* layerMaterial = nullptr;
       // -- material with 1D binning
       Trk::BinUtility layerBinUtility1DZ(m_barrelLayerBinsZ,-layerHalflength, layerHalflength, Trk::open, Trk::binZ);
       if (m_barrelLayerBinsPhi==1){
         // no binning in phi
         layerMaterial =new Trk::BinnedLayerMaterial(layerBinUtility1DZ);
       } else { // -- material with 2D binning : Rphi*Z optimized for cylinder layer
         Trk::BinUtility layerBinUtility2DRPhiZ(m_barrelLayerBinsPhi,
                                                -(*layerRadiusIter)*M_PI,
                                                (*layerRadiusIter)*M_PI,
                                                Trk::closed,
                                                Trk::binRPhi);
         layerBinUtility2DRPhiZ += layerBinUtility1DZ;
         layerMaterial =new Trk::BinnedLayerMaterial(layerBinUtility2DRPhiZ);
       }
       // Barrel layers are centered around (0,0,0) by definition
       barrelLayers->push_back(new Trk::CylinderLayer(new Trk::CylinderBounds(*layerRadiusIter,layerHalflength),
                                                      *layerMaterial,
                                                      m_layerThickness));
       ATH_MSG_VERBOSE( " --> Creating a layer at radius : " << *layerRadiusIter );
       delete layerMaterial;
     }
   } else {
  
     // (B) complex geometry section
     float nMaterialLayerStep  = 1.*nTotalBarrelLayers/m_modelBarrelLayers;
     // complex geo should build same # of mat. layers as model geo; counter to check this:
     unsigned int cMaterialLayerCount = 0;
     // inclusive layer counter over all rings, used to determine mat. layer position
     unsigned int cLayer=0;
  
     // loop over rings
     ATH_MSG_VERBOSE("TRT Barrel has " << nBarrelRings << " rings.");
  
     for (int ring=0; ring < nBarrelRings; ring++){
  
       int nBarrelLayers = trtNums->getNBarrelLayers(ring);
       ATH_MSG_VERBOSE("-> Ring " << ring << " has " << nBarrelLayers << " barrel layers.");
       // loop over layers
       for (int layer=0; layer < nBarrelLayers; layer++){
  
         // ----------------------------------------------------------------------------------
         ATH_MSG_VERBOSE("--> Layer " << layer << " is being built with " << nBarrelPhiSectors << " secors in phi.");
  
         // increase inclusive layer counter for next material layer
         ++cLayer;
  
         // set layer dimensions radius
         double layerRadius         =  0.;
         double layerRadiusMin      =  10e10;
         double layerRadiusMax      =  0.;
         double layerPhiMin         =  10.;
         double layerPhiMax         = -10;
  
         // per phi sector we make a 2D binnin in phi-z
         std::vector< std::pair<Trk::BinnedArray<Trk::Surface>*, Amg::Vector3D >  > layerSectorArrays;
         Amg::Vector3D layerSectorPosition(0.,0.,0.);
  
         // the sector approaching surfaces
         std::vector< std::pair< Trk::SharedObject<const Trk::ApproachSurfaces>, Amg::Vector3D > > layerApproachSurfaces;
  
         // layer sector arrays
         for (int phisec=0; phisec < nBarrelPhiSectors; phisec++){
           // ----------------------------------------------------------------------------------
           ATH_MSG_VERBOSE("---> Sector " << phisec << " gahtering the details.");
           // -------------- a phi sector (expands in +/- z) -----------------------------------
  
           // order the straws onto layers
           std::vector< Trk::SurfaceOrderPosition > strawsPerPhiSecLayer;
           // get the min an max phi, the min and max z
           double phiMin       =  10.;
           double phiMax       = -10.;
           // sector stuff
           int    sectorStraws = 0;
           // positive and negative sector
           for (int posneg=0; posneg<2; ++posneg){
             // sort the elements
             const InDetDD::TRT_BarrelElement* currentElement = trtContainer->getBarrelDetElement(posneg, ring, phisec, layer); // TODO share this line
             // get overall dimensions only one time
             const Trk::PlaneSurface*    elementSurface = dynamic_cast<const Trk::PlaneSurface*>(&(currentElement->surface()));
             if (!elementSurface) {
               ATH_MSG_WARNING( "elementSurface: dynamic_cast to Trk::PlaneSurface failed - skipping ... ring/layer/phisec/posneg = " << ring << "/" << layer << "/" << phisec << "/" << posneg );
               continue;
             }
  
             // create teh approach surfaces --------------------------------------------------------------------------------------------------
             // getTransformFromRotTransl(Amg::RotationMatrix3D rot, Amg::Vector3D transl_vec )
             Trk::ApproachSurfaces* aSurfaces         = new Trk::ApproachSurfaces;
             const Amg::Transform3D& elementTransform = elementSurface->transform();
             const Amg::Vector3D&    elementCenter    = elementSurface->center();
             const Amg::Vector3D&    elementNormal    = elementSurface->normal();
             Amg::RotationMatrix3D   elementRotation  = elementTransform.rotation();
             // outer / inner
             Amg::Vector3D outerCenter(elementCenter+(0.5*m_layerThickness+m_layerStrawRadius)*elementNormal);
             Amg::Vector3D innerCenter(elementCenter-(0.5*m_layerThickness+m_layerStrawRadius)*elementNormal);
  
             // assign the layer sector position for the straw array ordering
             layerSectorPosition = elementSurface->center();
  
             // now register the two surfaces
             aSurfaces->push_back(new Trk::PlaneSurface(Amg::Transform3D(Amg::getTransformFromRotTransl(elementRotation, innerCenter))));
             aSurfaces->push_back(new Trk::PlaneSurface(Amg::Transform3D(Amg::getTransformFromRotTransl(elementRotation, outerCenter))));
  
             // now register it to for building the array
             layerApproachSurfaces.emplace_back( Trk::SharedObject<const Trk::ApproachSurfaces>(aSurfaces),elementCenter);
             // screen output
             ATH_MSG_VERBOSE("---> Sector " << phisec << " - posneg - " << posneg << " - with central phi = " << elementSurface->center().phi() );
             // sector phi centers
             takeSmallerBigger(layerPhiMin,layerPhiMax,elementSurface->center().phi());
  
             // loop over straws, fill them and find the phi boundaries
             for (unsigned int istraw=0; istraw<currentElement->nStraws(); ++istraw)
               {
                 Identifier strawId = trtIdHelper->straw_id(currentElement->identify(), istraw);
                 const Trk::Surface* currentStraw = &(currentElement->surface(strawId));
                 // get the phi values
                 double currentPhi = currentStraw->center().phi();
                 if (phisec == m_barrelSectorAtPiBoundary && currentPhi < 0.){
                   currentPhi  = M_PI + currentPhi;
                   currentPhi += M_PI;
                 }
                 // the layer radius
                 takeSmallerBigger(layerRadiusMin,layerRadiusMax,currentStraw->center().perp());
                 takeSmallerBigger(phiMin, phiMax, currentPhi);
                 // make the ordering position
                 Amg::Vector3D strawOrderPos(currentStraw->center());
                 /*
                  * The above line was using the nodel (not delete option for the old shared object
                  * now that SharedObject is a shared_ptr typedef do the same with empty deleter
                  */
                 // Something like
                 // Trk::SharedObject<Trk::Surface>  =
                 // std::make_shared<Trk::Surface>(.....)) 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.
                 Trk::SharedObject<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(currentStraw),
                                                               Trk::do_not_delete<Trk::Surface>);
                 strawsPerPhiSecLayer.emplace_back(sharedSurface, strawOrderPos);
                 // and record
                 ++sectorStraws;
               } // loop over straws done
           }  // loop over posneg done
           // show the phiMin/phiMax to the screen
           // prepare the
           // fix to CID 24918
           if (!sectorStraws) {
             return nullptr;
           }
           double deltaPhi  = (phiMax-phiMin);
           double phiStep   = deltaPhi/(0.5*sectorStraws-1);
           ATH_MSG_VERBOSE("---> Sector " << phisec << " - with " << 0.5*sectorStraws << " straws - straw phiMin/phiMax (step) = " << phiMin << " / " << phiMax << " (" << phiStep << ")");
           // phi min / phi max
           phiMin -= 0.5*phiStep;
           phiMax += 0.5*phiStep;
           // correct for the +pi/-pi module
           // now create the BinUtility
           Trk::BinUtility* layerStrawPhiZUtility     = new Trk::BinUtility(sectorStraws/2,phiMin,phiMax,Trk::open, Trk::binPhi);
           (*layerStrawPhiZUtility)  += Trk::BinUtility(2,-layerZmax, layerZmax, Trk::open, Trk::binZ);
           // create the 2D BinnedArray
           Trk::BinnedArray2D<Trk::Surface>* layerStrawPhiSector = new Trk::BinnedArray2D<Trk::Surface>(strawsPerPhiSecLayer,layerStrawPhiZUtility);
           ATH_MSG_VERBOSE("---> Sector " << phisec << " - BinnedArray for straws prepared for " << strawsPerPhiSecLayer.size() << " straws.");
           // fill the array
           layerSectorArrays.emplace_back(layerStrawPhiSector, layerSectorPosition);
           // ---------------- enf of phi sector ----------------------------------------------------
         } // loop over PhiSectors done
  
         // build the mean of the layer Radius
         layerRadius = 0.5*(layerRadiusMin+layerRadiusMax)+0.5*m_layerStrawRadius;
  
         bool assignMaterial = false;
         if (cLayer==(unsigned)int((cMaterialLayerCount+1)*nMaterialLayerStep)) {
           assignMaterial      = true;
           ++cMaterialLayerCount;
           ATH_MSG_VERBOSE( "--> Creating a material+straw layer at radius  : " << layerRadius );
         } else
           ATH_MSG_VERBOSE( "--> Creating a straw          layer at radius  : " << layerRadius );
  
         // now order the plane layers to sit on cylindrical layers
         Trk::CylinderBounds* barrelLayerBounds = new Trk::CylinderBounds(layerRadius, layerHalflength);
  
         // ---- correct phi -------------------------------------------------------------------
         ATH_MSG_VERBOSE("    prepare approach description with " << nBarrelPhiSectors << " barrel sectors.");
         ATH_MSG_VERBOSE("    min phi / max phi detected  : " << layerPhiMin << " / " << layerPhiMax );
         double layerPhiMinCorrected = layerPhiMin-0.5*layerPhiStep;
         double layerPhiMaxCorrected = layerPhiMax+0.5*layerPhiStep;
         // catch if the minPhi falls below M_PI
         if (layerPhiMinCorrected < -M_PI){
           layerPhiMinCorrected += layerPhiStep;
           layerPhiMaxCorrected += layerPhiStep;
         }
         ATH_MSG_VERBOSE("    min phi / max phi corrected : " << layerPhiMinCorrected << " / " << layerPhiMaxCorrected );
  
         // the sector surfaces
         Trk::BinUtility* layerSectorBinUtility = new Trk::BinUtility(nBarrelPhiSectors,layerPhiMinCorrected,layerPhiMaxCorrected,Trk::closed,Trk::binPhi);
         auto strawArray = std::make_unique<Trk::BinnedArrayArray<Trk::Surface>>(layerSectorArrays, layerSectorBinUtility );
  
         ATH_MSG_VERBOSE("--> Layer " << layer << " has been built with " << strawArray->arrayObjects().size() << " straws.");
  
         // ApproachDescriptor
         // build a BinUtility for the ApproachDescritptor
         Trk::BinUtility* aDescriptorBinUtility = new Trk::BinUtility(nBarrelPhiSectors,layerPhiMinCorrected,layerPhiMaxCorrected,Trk::closed,Trk::binPhi);
         (*aDescriptorBinUtility) += Trk::BinUtility(2,-layerHalflength,layerHalflength,Trk::open, Trk::binZ);
  
         auto aDescriptorBinnedArray = std::make_unique<Trk::BinnedArray2D<const Trk::ApproachSurfaces>> (layerApproachSurfaces, aDescriptorBinUtility);
  
         // build an approach surface
         auto approachSurface = std::make_unique<Trk::CylinderSurface> (barrelLayerBounds->clone());
         Trk::ApproachDescriptor* aDescritpor =
           new Trk::ApproachDescriptor(std::move(aDescriptorBinnedArray),
                                       std::move( approachSurface));
  
         // do not give every layer material properties
         if (assignMaterial) {
           // ----- prepare the BinnedLayerMaterial -----------------------------------------------------
           Trk::BinnedLayerMaterial* layerMaterial = nullptr;
           // -- material with 1D binning
           Trk::BinUtility layerBinUtilityZ(m_barrelLayerBinsZ, -layerHalflength, layerHalflength, Trk::open, Trk::binZ );
           if (m_barrelLayerBinsPhi==1){
             layerMaterial =new Trk::BinnedLayerMaterial(layerBinUtilityZ);
           } else { // -- material with 2D binning: RPhiZ binning
             Trk::BinUtility layerBinUtilityRPhiZ(m_barrelLayerBinsPhi,
                                                  -layerRadius*M_PI, layerRadius*M_PI,
                                                  Trk::closed,
                                                  Trk::binRPhi);
             layerBinUtilityRPhiZ += layerBinUtilityZ;
             layerMaterial =new Trk::BinnedLayerMaterial(layerBinUtilityRPhiZ);
           }
  
           barrelLayers->push_back(new Trk::CylinderLayer(barrelLayerBounds,
                                                          std::move(strawArray),
                                                          *layerMaterial,
                                                          m_layerThickness,
                                                          std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                          aDescritpor));
           delete layerMaterial;
  
         } else
           barrelLayers->push_back(new Trk::CylinderLayer(barrelLayerBounds,
                                                          std::move(strawArray),
                                                          m_layerThickness,
                                                          std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                          aDescritpor));
       } // loop over layers
     } // loop over rings
  
     ATH_MSG_VERBOSE(" Built number of TRT barrel material layers: " << cMaterialLayerCount);
     // In Complex geo # of material layers should match the expected # of layers,
     // else a mis-match in layer and material map index occurs.
     // This mis-match will results layers getting incorrect material properties.
     if (cMaterialLayerCount!=m_modelBarrelLayers) {
       ATH_MSG_WARNING(" Complex geo built incorrect # of TRT barrel material layers: "
                       << cMaterialLayerCount <<  " / " <<  m_modelBarrelLayers);
     }
   }// complex geometry
  
   // return what you have
   return std::unique_ptr<const std::vector<Trk::CylinderLayer*> > (barrelLayers.release());
 }

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

95 { return m_detStore; }

◆ discLayersImpl()

std::unique_ptr< const std::vector< Trk::DiscLayer * > > InDet::TRT_LayerBuilderImpl::discLayersImpl ( const InDetDD::TRT_DetElementContainer * trtContainer ) const

protected

Definition at line 429 of file TRT_LayerBuilderImpl.cxx.

 {
   ATH_MSG_DEBUG( "Building disc-like layers for the TRT " );
  
   const InDetDD::TRT_Numerology* trtNums = trtContainer->getTRTNumerology();
   // get the TRT ID Helper
   const TRT_ID* trtIdHelper = nullptr;
   if (detStore()->retrieve(trtIdHelper, "TRT_ID").isFailure()) {
     ATH_MSG_ERROR("Could not get TRT ID helper");
     return nullptr;
   }
   unsigned int nEndcapWheels = trtNums->getNEndcapWheels();
   unsigned int nEndcapPhiSectors = trtNums->getNEndcapPhi();
  
   // total layer numbers
   int numTotalLayers = 0;
  
   // zMin / zMax
   double zMin = 10e10;
   double zMax = 0.;
  
   const Trk::DiscBounds* sectorDiscBounds = nullptr;
  
   // preloop for overall numbers
   for (unsigned int iwheel=0; iwheel<nEndcapWheels; ++iwheel)
     {
       unsigned int nEndcapLayers = trtNums->getNEndcapLayers(iwheel);
       numTotalLayers += nEndcapLayers;
       for (unsigned int ilayer = 0; ilayer<nEndcapLayers; ++ilayer){
         const InDetDD::TRT_EndcapElement* sectorDiscElement = trtContainer->getEndcapDetElement(0, iwheel, ilayer, 0); // TODO share this line
  
         // get a reference element for dimensions
         if (!sectorDiscBounds){
           sectorDiscBounds = dynamic_cast<const Trk::DiscBounds*>(&(sectorDiscElement->bounds()));
         }
  
         double currentZ = std::abs(sectorDiscElement->center().z());
         takeSmallerBigger(zMin,zMax,currentZ);
       }
     }
   if (numTotalLayers==0) {
     ATH_MSG_WARNING( "numTotalLayers = 0 ... aborting and returning 0 !" );
     return nullptr;
   }
  
   if (!sectorDiscBounds) {
     ATH_MSG_WARNING( "fullDiscBounds do not exist ... aborting and returning 0 !" );
     return nullptr;
   }
   auto fullDiscBounds = std::make_unique<Trk::DiscBounds>(sectorDiscBounds->rMin(), sectorDiscBounds->rMax());
  
   PtrVectorWrapper<Trk::DiscLayer> endcapLayers;
  
   // the BinUtility for the material
   std::unique_ptr<Trk::BinnedLayerMaterial> layerMaterial;
   // -- material with 1D binning
   Trk::BinUtility layerBinUtilityR(m_endcapLayerBinsR,
                                    fullDiscBounds->rMin(),
                                    fullDiscBounds->rMax(),
                                    Trk::open,
                                    Trk::binR);
   if (m_barrelLayerBinsPhi==1)
     layerMaterial = std::make_unique<Trk::BinnedLayerMaterial>(layerBinUtilityR);
   else { // -- material with 2D binning
     Trk::BinUtility layerBinUtilityPhi(m_barrelLayerBinsPhi,
                                        -M_PI, M_PI,
                                        Trk::closed,
                                        Trk::binPhi);
     // make it rPhi now
     layerBinUtilityR += layerBinUtilityPhi;
     layerMaterial = std::make_unique<Trk::BinnedLayerMaterial>(layerBinUtilityR);
   }
  
   // global geometry statistics
   double zDiff      = std::abs(zMax-zMin);
   double zStep      = zDiff/(m_modelEndcapLayers+1);
  
   // loop for surface ordering
   int maxendcaps=2;
   if (m_endcapConly) maxendcaps=1;
  
   for (int iposneg=0; iposneg<maxendcaps; ++iposneg){
  
     // fill the positions of the disc layers
     std::vector<double> zPositions;
     zPositions.reserve(m_modelEndcapLayers);
  
     double stepdir = iposneg ? 1. : -1.;
     double zStart = stepdir*zMin;
  
     ATH_MSG_VERBOSE( " -> Creating " << m_modelEndcapLayers << " disc-layers on each side between "
                      << zMin << " and " << zMax << " ( at step "<< zStep << " )");
  
     // take a different modelling for the layers - use these layers for the model geometry and the real geometry
     for (unsigned int izpos = 1; izpos <= m_modelEndcapLayers; ++izpos){
       zPositions.push_back(zStart + stepdir * double(izpos) * zStep - 0.5 * m_layerThickness);
     }
  
     std::vector<double>::const_iterator zPosIter    = zPositions.begin();
     std::vector<double>::const_iterator zPosIterEnd = zPositions.end();
  
     // (a) simplified geometry
     if (m_modelGeometry){
       // build the layers actually
       for ( ; zPosIter != zPosIterEnd; ++zPosIter){
         ATH_MSG_VERBOSE( "  --> Creating a layer at z pos    : " << (*zPosIter) );
         Amg::Transform3D zPosTrans =
           Amg::Transform3D(Amg::Translation3D(0., 0., (*zPosIter)));
         endcapLayers->push_back(new Trk::DiscLayer(zPosTrans,
                                                    fullDiscBounds->clone(),
                                                    *layerMaterial,
                                                    m_layerThickness));
       }
  
     } else {
       // (b) complex geometry
       float nMaterialLayerStep  = 1.*numTotalLayers/m_modelEndcapLayers;
       // inclusive layer counter over all wheels
       unsigned int cLayer = 0;
       // complex geo should build same # of mat. layers as model geo; counter to check this:
       unsigned int  cMaterialLayerCount = 0;
  
       // complex geometry - needs a little bit of joggling
       for (unsigned int iwheel=0; iwheel<nEndcapWheels; ++iwheel)
         {
           // do the loop per side
           unsigned int nEndcapLayers = trtNums->getNEndcapLayers(iwheel);
           for (unsigned int ilayer = 0; ilayer < nEndcapLayers; ++ilayer){
  
             // increase inclusive layer counter for next material layer
             ++cLayer;
  
             // count the straws;
             int numberOfStraws = 0;
  
             // check if dynamic cast worked
             if (fullDiscBounds){
               // get a reference element for dimensions
               const InDetDD::TRT_EndcapElement* sectorDiscElement = trtContainer->getEndcapDetElement(iposneg, iwheel, ilayer, 0); // TODO share this line
  
               // take the position, but not the rotation (the rotation has to be standard)
               Amg::Vector3D fullDiscPosition(sectorDiscElement->surface().transform().translation());
               double discZ = fullDiscPosition.z();
  
               // check if we need to build a straw layer or not
               bool assignMaterial = false;
               if (cLayer == (unsigned)int((cMaterialLayerCount+1)*nMaterialLayerStep)) {
                 assignMaterial      = true;
                 ++cMaterialLayerCount;
                 ATH_MSG_VERBOSE( "--> Creating a material+straw layer at z-pos   : " << discZ );
               } else {
                 ATH_MSG_VERBOSE( "--> Creating a straw          layer at z-pos   : " << discZ );
               }
  
               // order the straws onto layers
               std::vector< Trk::SurfaceOrderPosition > strawPerEndcapLayer;
  
               // the layer thickness - for approaching surfaces
               double zMin = 10e10;
               double zMax = -10e10;
  
               for (unsigned int iphisec=0; iphisec<nEndcapPhiSectors; ++iphisec){
                 ATH_MSG_VERBOSE("Building sector " << iphisec << " of endcap wheel " << iwheel );
                 const InDetDD::TRT_EndcapElement* currentElement = trtContainer->getEndcapDetElement(iposneg, iwheel, ilayer, iphisec); // TODO share this line
                 unsigned int nstraws = currentElement->nStraws();
                 for (unsigned int istraw=0; istraw<nstraws; istraw++){
                   Identifier strawId = trtIdHelper->straw_id(currentElement->identify(), istraw);
                   const Trk::Surface* currentStraw = &(currentElement->surface(strawId));
                   Amg::Vector3D strawOrderPos(currentStraw->center());
                   // get the z position
                   double zPos = currentStraw->center().z();
                   takeSmaller(zMin,zPos);
                   takeBigger(zMax,zPos);
                   // Something like
                   // Trk::SharedObject<Trk::Surface>  =
                   // std::make_shared<Trk::Surface>(currentElement)) 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.
                   Trk::SharedObject<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(currentStraw),
                                                                 [](Trk::Surface*) {});
                   strawPerEndcapLayer.emplace_back(sharedSurface, strawOrderPos);
                   ++numberOfStraws;
                 }
               }
               // fix to CID 11326
               if (!numberOfStraws){
                 return nullptr;
               }
               Trk::BinUtility* currentBinUtility = new Trk::BinUtility(numberOfStraws, -M_PI, M_PI, Trk::closed, Trk::binPhi);
               auto strawArray = std::make_unique<Trk::BinnedArray1D<Trk::Surface>>(strawPerEndcapLayer, currentBinUtility);
               Trk::DiscLayer* currentLayer = nullptr;
  
               // redefine the discZ
               discZ = 0.5*(zMin+zMax);
               Amg::Transform3D fullDiscTransform = Amg::Transform3D(Amg::Translation3D(0.,0.,discZ));
  
               ATH_MSG_VERBOSE("TRT Disc being build at z Position " << discZ << " ( from " << zMin << " / " << zMax << " )");
  
               // create the approach offset
               auto aSurfaces = std::make_unique<Trk::ApproachSurfaces>();
               // get the position of the approach surfaces
               const Amg::Vector3D aspPosition(0.,0.,zMin-m_layerStrawRadius);
               const Amg::Vector3D asnPosition(0.,0.,zMax+m_layerStrawRadius);
  
               // create new surfaces
               Amg::Transform3D  asnTransform = Amg::Transform3D(Amg::Translation3D(asnPosition));
               Amg::Transform3D  aspTransform = Amg::Transform3D(Amg::Translation3D(aspPosition));
               // order in an optimised way for collision direction
               if (discZ > 0.){
                 aSurfaces->push_back( new Trk::DiscSurface(asnTransform, fullDiscBounds->clone()) );
                 aSurfaces->push_back( new Trk::DiscSurface(aspTransform, fullDiscBounds->clone()) );
               } else {
                 aSurfaces->push_back( new Trk::DiscSurface(aspTransform, fullDiscBounds->clone()) );
                 aSurfaces->push_back( new Trk::DiscSurface(asnTransform, fullDiscBounds->clone()) );
               }
               // approach descriptor
               Trk::ApproachDescriptor* aDescriptor = new Trk::ApproachDescriptor(std::move(aSurfaces),false);
  
               // do not give every layer material properties
               if (assignMaterial)
                 currentLayer = new Trk::DiscLayer(fullDiscTransform,
                                                   fullDiscBounds->clone(),
                                                   std::move(strawArray),
                                                   *layerMaterial,
                                                   m_layerThickness,
                                                   std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                   aDescriptor);
               else if (!m_modelGeometry)
                 currentLayer = new Trk::DiscLayer(fullDiscTransform,
                                                   fullDiscBounds->clone(),
                                                   std::move(strawArray),
                                                   m_layerThickness,
                                                   std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                   aDescriptor);
  
               if (currentLayer) endcapLayers->push_back(currentLayer);
             } // end of sectorDiscBounds if
           } // end of layer loop
         } // end of wheel loop
  
       ATH_MSG_VERBOSE(" Built # of TRT material layers: " << cMaterialLayerCount << "in ispos: " << iposneg << "ring");
       // # of material layers should match the expected # of layers,
       // else a mis-match in layer and material map index occurs.
       // This mis-match will results layers getting incorrect material properties.
       if (cMaterialLayerCount != m_modelEndcapLayers) {
         ATH_MSG_WARNING(" Built incorrect # of TRT material layers: "
                         << cMaterialLayerCount <<  " / " << m_modelEndcapLayers <<  "in ispos" << iposneg << "ring" );
       }
  
     } // model/real geometry
   } // end of posneg loop
  
   return std::unique_ptr<const std::vector<Trk::DiscLayer*> > (endcapLayers.release());
 }

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

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

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

◆ 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() [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.

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

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

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

Friends And Related Function Documentation

◆ TRT_VolumeBuilder

friend class TRT_VolumeBuilder

friend

Declare the TRT_VolumeBuilder as friend.

Definition at line 54 of file TRT_LayerBuilderImpl.h.

Member Data Documentation

◆ m_barrelLayerBinsPhi

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

protected

Bins for the Barrel material - in phi.

Definition at line 78 of file TRT_LayerBuilderImpl.h.

◆ m_barrelLayerBinsZ

UnsignedIntegerProperty InDet::TRT_LayerBuilderImpl::m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 25}

protected

Bins for the Barrel material - in z.

Definition at line 77 of file TRT_LayerBuilderImpl.h.

◆ m_barrelSectorAtPiBoundary

IntegerProperty InDet::TRT_LayerBuilderImpl::m_barrelSectorAtPiBoundary {this, "BarrelSectorAtPi", 16}

protected

this is the barrel Sector where +pi/-pi is within

Definition at line 84 of file TRT_LayerBuilderImpl.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_endcapConly

BooleanProperty InDet::TRT_LayerBuilderImpl::m_endcapConly {this, "EndcapConly", false}

protected

Only build the endcapC.

Definition at line 81 of file TRT_LayerBuilderImpl.h.

◆ m_endcapLayerBinsPhi

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

protected

Bins for the Endcap material - in phi.

Definition at line 80 of file TRT_LayerBuilderImpl.h.

◆ m_endcapLayerBinsR

UnsignedIntegerProperty InDet::TRT_LayerBuilderImpl::m_endcapLayerBinsR {this, "EndcapLayerBinsR", 25}

protected

Bins for the Endcap material - in r.

Definition at line 79 of file TRT_LayerBuilderImpl.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_identification

StringProperty InDet::TRT_LayerBuilderImpl::m_identification {this, "Identification", "TRT"}

protected

string identification

Definition at line 86 of file TRT_LayerBuilderImpl.h.

◆ m_layerStrawRadius

double InDet::TRT_LayerBuilderImpl::m_layerStrawRadius {2.0*Gaudi::Units::mm}

protected

straw radius

Definition at line 71 of file TRT_LayerBuilderImpl.h.

◆ m_layerThickness

DoubleProperty InDet::TRT_LayerBuilderImpl::m_layerThickness {this, "LayerThickness", 0.1*Gaudi::Units::mm}

protected

modelled layer thickness

Definition at line 72 of file TRT_LayerBuilderImpl.h.

◆ m_modelBarrelLayers

UnsignedIntegerProperty InDet::TRT_LayerBuilderImpl::m_modelBarrelLayers {this, "ModelBarrelLayers", 7}

protected

model barrel layers with material

Definition at line 74 of file TRT_LayerBuilderImpl.h.

◆ m_modelEndcapLayers

UnsignedIntegerProperty InDet::TRT_LayerBuilderImpl::m_modelEndcapLayers {this, "ModelEndcapLayers", 14}

protected

model endcap layers with material

Definition at line 75 of file TRT_LayerBuilderImpl.h.

◆ m_modelGeometry

BooleanProperty InDet::TRT_LayerBuilderImpl::m_modelGeometry {this, "ModelLayersOnly", true}

protected

Build the geometry with model layers.

Definition at line 73 of file TRT_LayerBuilderImpl.h.

◆ m_registerStraws

BooleanProperty InDet::TRT_LayerBuilderImpl::m_registerStraws {this, "RegisterStraws", false}

protected

register the straws

Definition at line 83 of file TRT_LayerBuilderImpl.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.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ~TRT_LayerBuilderImpl()

◆ TRT_LayerBuilderImpl()

Member Function Documentation

◆ cylindricalLayersImpl()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ discLayersImpl()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Friends And Related Function Documentation

◆ TRT_VolumeBuilder

Member Data Documentation

◆ m_barrelLayerBinsPhi

◆ m_barrelLayerBinsZ

◆ m_barrelSectorAtPiBoundary

◆ m_detStore

◆ m_endcapConly

◆ m_endcapLayerBinsPhi

◆ m_endcapLayerBinsR

◆ m_evtStore

◆ m_identification

◆ m_layerStrawRadius

◆ m_layerThickness

◆ m_modelBarrelLayers

◆ m_modelEndcapLayers

◆ m_modelGeometry

◆ m_registerStraws

◆ m_varHandleArraysDeclared

◆ m_vhka