InDet::TRT_LayerBuilderImpl Class Reference

#include <TRT_LayerBuilderImpl.h>

Inheritance diagram for InDet::TRT_LayerBuilderImpl:

Collaboration diagram for InDet::TRT_LayerBuilderImpl:

Public Member Functions
virtual	~TRT_LayerBuilderImpl ()=default
	Destructor.
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
	TRT_LayerBuilderImpl (const std::string &, const std::string &, const IInterface *)
	AlgTool style constructor.
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
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
double	m_layerStrawRadius {2.0*Gaudi::Units::mm}
	straw radius
DoubleProperty	m_layerThickness {this, "LayerThickness", 0.1*Gaudi::Units::mm}
	modelled layer thickness
BooleanProperty	m_modelGeometry {this, "ModelLayersOnly", true}
	Build the geometry with model layers.
UnsignedIntegerProperty	m_modelBarrelLayers {this, "ModelBarrelLayers", 7}
	model barrel layers with material
UnsignedIntegerProperty	m_modelEndcapLayers {this, "ModelEndcapLayers", 14}
	model endcap layers with material
UnsignedIntegerProperty	m_barrelLayerBinsZ {this, "BarrelLayerBinsZ", 25}
	Bins for the Barrel material - in z.
UnsignedIntegerProperty	m_barrelLayerBinsPhi {this, "BarrelLayerBinsPhi", 1}
	Bins for the Barrel material - in phi.
UnsignedIntegerProperty	m_endcapLayerBinsR {this, "EndcapLayerBinsR", 25}
	Bins for the Endcap material - in r.
UnsignedIntegerProperty	m_endcapLayerBinsPhi {this, "EndcapLayerBinsPhi", 1}
	Bins for the Endcap material - in phi.
BooleanProperty	m_endcapConly {this, "EndcapConly", false}
	Only build the endcapC.
BooleanProperty	m_registerStraws {this, "RegisterStraws", false}
	register the straws
IntegerProperty	m_barrelSectorAtPiBoundary {this, "BarrelSectorAtPi", 16}
	this is the barrel Sector where +pi/-pi is within
StringProperty	m_identification {this, "Identification", "TRT"}
	string identification

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

Friends
class	TRT_VolumeBuilder
	Declare the TRT_VolumeBuilder as friend.

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 59 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 66 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==1u){
        // 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(std::make_shared<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::BinnedArray2D<Trk::Surface>, Amg::Vector3D >  > layerSectorArrays;
        Amg::Vector3D layerSectorPosition(0.,0.,0.);
 
        // the sector approaching surfaces
        std::vector< std::pair< std::shared_ptr<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( std::shared_ptr<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
                // std::shared_ptr<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.
                std::shared_ptr<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
          //coverity[DIVIDE_BY_ZERO:FALSE]
          auto layerStrawPhiZUtility = 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(strawsPerPhiSecLayer,layerStrawPhiZUtility);
          ATH_MSG_VERBOSE("---> Sector " << phisec << " - BinnedArray for straws prepared for " << strawsPerPhiSecLayer.size() << " straws.");
          // fill the array
          layerSectorArrays.emplace_back(std::move(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
        auto  barrelLayerBounds = std::make_shared<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
        auto layerSectorBinUtility = Trk::BinUtility(nBarrelPhiSectors,layerPhiMinCorrected,layerPhiMaxCorrected,Trk::closed,Trk::binPhi);
        auto strawArray = std::make_unique<Trk::BinnedArrayArray2D<Trk::Surface>>(std::move(layerSectorArrays), layerSectorBinUtility );
 
        ATH_MSG_VERBOSE("--> Layer " << layer << " has been built with " << strawArray->arrayObjects().size() << " straws.");
 
        // ApproachDescriptor
        // build a BinUtility for the ApproachDescritptor
        auto aDescriptorBinUtility = 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>(
            std::make_shared<Trk::CylinderBounds>(*barrelLayerBounds));
        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==1u){
            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()

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

discLayersImpl()

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

protected

Definition at line 432 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==1u)
    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,
                                                   std::make_shared<Trk::DiscBounds>(*fullDiscBounds),
                                                   *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
              // 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
                  // std::shared_ptr<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.
                  std::shared_ptr<Trk::Surface> sharedSurface(const_cast<Trk::Surface*>(currentStraw),
                                                                [](Trk::Surface*) {});
                  strawPerEndcapLayer.emplace_back(sharedSurface, strawOrderPos);
                  ++numberOfStraws;
                }
              }
              // fix to CID 11326
              if (!numberOfStraws){
                return nullptr;
              }
              auto currentBinUtility = 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, std::make_shared<Trk::DiscBounds>(*fullDiscBounds)));
                aSurfaces->push_back( new Trk::DiscSurface(aspTransform, std::make_shared<Trk::DiscBounds>(*fullDiscBounds)) );
              } else {
                aSurfaces->push_back( new Trk::DiscSurface(aspTransform, std::make_shared<Trk::DiscBounds>(*fullDiscBounds)) );
                aSurfaces->push_back( new Trk::DiscSurface(asnTransform, std::make_shared<Trk::DiscBounds>(*fullDiscBounds)) );
              }
              // 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,
                                                  std::make_shared<Trk::DiscBounds>(*fullDiscBounds),
                                                  std::move(strawArray),
                                                  *layerMaterial,
                                                  m_layerThickness,
                                                  std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                  aDescriptor);
              else if (!m_modelGeometry)
                currentLayer = new Trk::DiscLayer(fullDiscTransform,
                                                  std::make_shared<Trk::DiscBounds>(*fullDiscBounds),
                                                  std::move(strawArray),
                                                  m_layerThickness,
                                                  std::make_unique<InDet::TRT_OverlapDescriptor>(trtIdHelper),
                                                  aDescriptor);
 
              if (currentLayer) endcapLayers->push_back(currentLayer);
          } // 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()

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

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.

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

{this, "BarrelLayerBinsPhi", 1};       

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.

{this, "BarrelLayerBinsZ", 25};         

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.

{this, "BarrelSectorAtPi", 16}; 

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.

{this, "EndcapConly", false};              

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.

{this, "EndcapLayerBinsPhi", 1};       

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.

{this, "EndcapLayerBinsR", 25};         

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.

{this, "Identification", "TRT"};           

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.

{2.0*Gaudi::Units::mm}; 

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.

{this, "LayerThickness", 0.1*Gaudi::Units::mm};           

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.

{this, "ModelBarrelLayers", 7};        

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.

{this, "ModelEndcapLayers", 14};        

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.

{this, "ModelLayersOnly", true};            

m_registerStraws

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

protected

register the straws

Definition at line 83 of file TRT_LayerBuilderImpl.h.

{this, "RegisterStraws", false};           

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:

• TRT_LayerBuilderImpl.h
• TRT_LayerBuilderImpl.cxx