Calo::CaloTrackingGeometryBuilder Class Reference

#include <CaloTrackingGeometryBuilder.h>

Inheritance diagram for Calo::CaloTrackingGeometryBuilder:

Collaboration diagram for Calo::CaloTrackingGeometryBuilder:

Public Member Functions
	CaloTrackingGeometryBuilder (const std::string &, const std::string &, const IInterface *)
	Constructor. More...
virtual	~CaloTrackingGeometryBuilder ()=default
	Destructor. More...
virtual StatusCode	initialize () override
	AlgTool initailize method. More...
virtual std::unique_ptr< Trk::TrackingGeometry >	trackingGeometry (Trk::TrackingVolume *tvol=0) const override
	TrackingGeometry Interface methode. More...
virtual Trk::GeometrySignature	geometrySignature () const override final
	The unique signature. More...
std::unique_ptr< Trk::TrackingGeometry >	createTrackingGeometry (Trk::TrackingVolume *innerVol, const CaloDetDescrManager *caloDDM, const GeoAlignmentStore *geoAlign) const
	TrackingGeometry Interface method. More...
Trk::GeometrySignature	signature () const
	The unique signature. 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
	DeclareInterfaceID (IGeometryBuilder, 1, 0)
	Creates the InterfaceID and interfaceID() method. More...

Protected Member Functions
void	registerInLayerIndexCaloSampleMap (Trk::LayerIndexSampleMap &licsMAp, const std::vector< CaloCell_ID::CaloSample > &ccid, const Trk::TrackingVolume &vol, int side=1) const
	method to establish a link between the LayerIndex and the CaloCell_ID in an associative container More...
std::pair< Trk::TrackingVolume *, Trk::TrackingVolume * >	createBeamPipeVolumes (const RZPairVector &bpCutouts, float, float, const std::string &, float &) const
	method to build enclosed beam pipe volumes More...
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
PublicToolHandle< Trk::ITrackingVolumeArrayCreator >	m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}
	Helper Tool to create TrackingVolumes. More...
PublicToolHandle< Trk::ITrackingVolumeHelper >	m_trackingVolumeHelper {this, "TrackingVolumeHelper", "Trk::TrackingVolumeHelper/TrackingVolumeHelper"}
	Second helper for volume creation. More...
PublicToolHandle< Trk::ITrackingVolumeCreator >	m_trackingVolumeCreator {this, "TrackingVolumeCreator", "Trk::CylinderVolumeCreator/TrackingVolumeCreator"}
	Volume Builder for the Liquid Argon Calorimeter. More...
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder >	m_lArVolumeBuilder {this, "LArVolumeBuilder", "LAr::LArVolumeBuilder/LArVolumeBuilder"}
	Volume Builder for the Tile Calorimeter. More...
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder >	m_tileVolumeBuilder {this, "TileVolumeBuilder", "Tile::TileVolumeBuilder/TileVolumeBuilder"}
	Material properties. More...
Trk::Material	m_caloMaterial {}
Trk::Material	m_Ar {140.036, 856.32, 39.948, 18., 0.0014}
Trk::Material	m_Al {88.93, 388.62, 26.98, 13., 0.0027}
Trk::Material	m_Scint {424.35, 707.43, 11.16, 5.61, 0.001}
Trk::Material	m_crackMaterial {424.35, 707.43, 11.16, 5.61, 0.001}
DoubleProperty	m_caloEnvelope {this, "GapLayerEnvelope", 25 * Gaudi::Units::mm}
	Envelope cover for Gap Layers. More...
ServiceHandle< IEnvelopeDefSvc >	m_enclosingEnvelopeSvc {this, "EnvelopeDefinitionSvc", "AtlasGeometry_EnvelopeDefSvc"}
DoubleProperty	m_caloDefaultRadius {this, "CalorimeterRadius", 4250.}
	the radius if not built from GeoModel More...
DoubleProperty	m_caloDefaultHalflengthZ {this, "CalorimeterHalflengthZ", 6500.}
	the halflength in z if not built from More...
BooleanProperty	m_indexStaticLayers {this, "IndexStaticLayers", true}
	forces robust indexing for layers More...
BooleanProperty	m_recordLayerIndexCaloSampleMap {this, "RecordLayerIndexCaloSampleMap", true}
	for deposition methods More...
StringProperty	m_layerIndexCaloSampleMapName {this, "LayerIndexCaloSampleMapName", "LayerIndexCaloSampleMap"}
	name to record it More...
BooleanProperty	m_buildMBTS {this, "BuildMBTS", true}
	MBTS like detectors. More...
std::vector< double >	m_mbtsRadiusGap
	MBTS like detectors. More...
std::vector< int >	m_mbtsPhiSegments
	MBTS like detectors. More...
std::vector< double >	m_mbtsPhiGap
	MBTS like detectors. More...
std::vector< double >	m_mbtsPositionZ
	MBTS like detectors. More...
std::vector< double >	m_mbtsStaggeringZ
	MBTS like detectors. More...
StringProperty	m_entryVolume {this, "EntryVolumeName", "Calo::Container::EntryVolume"}
	name of the Calo entrance More...
StringProperty	m_exitVolume {this, "ExitVolumeName", "Calo::Container"}
	name of the Calo container 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

Detailed Description

Retrieves the volume builders from Tile and LAr and combines the given volumes to a calorimeter tracking geometry.

Author

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

Christos Anastopoulos Athena MT

Definition at line 26 of file CaloTrackingGeometryBuilder.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

CaloTrackingGeometryBuilder()

Calo::CaloTrackingGeometryBuilder::CaloTrackingGeometryBuilder	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Constructor.

Definition at line 15 of file CaloTrackingGeometryBuilder.cxx.

    : Calo::CaloTrackingGeometryBuilderImpl(t, n, p) {
  declareInterface<Trk::IGeometryBuilder>(this);
}

~CaloTrackingGeometryBuilder()

virtual Calo::CaloTrackingGeometryBuilder::~CaloTrackingGeometryBuilder ( )

virtualdefault

Destructor.

Member Function Documentation

createBeamPipeVolumes()

std::pair< Trk::TrackingVolume *, Trk::TrackingVolume * > Calo::CaloTrackingGeometryBuilderImpl::createBeamPipeVolumes ( const RZPairVector &  bpCutouts, float  zmin, float  zmax, const std::string &  name, float &  outerRadius  ) const

protectedinherited

method to build enclosed beam pipe volumes

Definition at line 1479 of file CaloTrackingGeometryBuilderImpl.cxx.

                                                     {
  outerRadius = 0.;
 
  // dummy objects
  Trk::LayerArray* dummyLayers = nullptr;
  Trk::TrackingVolumeArray* dummyVolumes = nullptr;
 
  // beam pipe thickness along the z distance
  if (bpCutouts.empty()) {
    return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(0, 0);
  }
 
  RZPairVector dim;
  dim.emplace_back(bpCutouts[0].first, zmin);
  float rOut = bpCutouts[0].first;
  for (const auto& bpCutout : bpCutouts) {
    if (bpCutout.second <= dim[0].second)
      dim[0].first = bpCutout.first;
    else if (bpCutout.second <= zmax)
      dim.push_back(bpCutout);
    if (bpCutout.second <= zmax)
      rOut = bpCutout.first;
  }
 
  if (dim.back().second < zmax)
    dim.emplace_back(rOut, zmax);
 
  if (dim.size() == 2) {  // simple case
 
    outerRadius = dim[0].first;
 
    Trk::CylinderVolumeBounds* bpBounds =
        new Trk::CylinderVolumeBounds(0., outerRadius, 0.5 * (zmax - zmin));
 
    Amg::Transform3D* bpPos = new Amg::Transform3D(
        Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin + zmax))));
 
    Trk::TrackingVolume* bpVolPos =
        new Trk::TrackingVolume(bpPos, bpBounds, m_caloMaterial, dummyLayers,
                                dummyVolumes, "BeamPipe::Positive" + name);
 
    Amg::Transform3D* bpNeg = new Amg::Transform3D(
        Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zmin + zmax))));
 
    Trk::TrackingVolume* bpVolNeg = new Trk::TrackingVolume(
        bpNeg, bpBounds->clone(), m_caloMaterial, dummyLayers, dummyVolumes,
        "BeamPipe::Negative" + name);
 
    // geometry signature
    bpVolPos->sign(Trk::BeamPipe);
    bpVolNeg->sign(Trk::BeamPipe);
 
    return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(bpVolPos,
                                                                 bpVolNeg);
  }
 
  // cutout included
 
  outerRadius = dim[0].first;
 
  // find rMax
  for (unsigned int i = 1; i < dim.size(); i++)
    if (dim[i].first > outerRadius)
      outerRadius = dim[i].first;
 
  // loop over z sections, prepare volumes for gluing
  std::vector<Trk::TrackingVolume*> posVols;
 
  for (unsigned int i = 0; i < dim.size() - 1; i++) {
 
    if (dim[i].second == dim[i + 1].second)
      continue;
 
    // beam pipe volume
    Trk::CylinderVolumeBounds* bpBounds = new Trk::CylinderVolumeBounds(
        0., dim[i].first, 0.5 * (dim[i + 1].second - dim[i].second));
 
    Amg::Transform3D* bpPos = new Amg::Transform3D(Amg::Translation3D(
        Amg::Vector3D(0., 0., 0.5 * (dim[i + 1].second + dim[i].second))));
 
    Trk::TrackingVolume* bpVolPos =
        new Trk::TrackingVolume(bpPos, bpBounds, m_caloMaterial, dummyLayers,
                                dummyVolumes, "BeamPipe::Positive" + name);
    bpVolPos->sign(Trk::BeamPipe);
 
    Trk::TrackingVolume* bpVolGap = nullptr;
    if (dim[i].first < outerRadius) {
 
      Trk::CylinderVolumeBounds* bpGB = new Trk::CylinderVolumeBounds(
          dim[i].first, outerRadius, 0.5 * (dim[i + 1].second - dim[i].second));
 
      Amg::Transform3D* bpPB = new Amg::Transform3D(*bpPos);
 
      bpVolGap = new Trk::TrackingVolume(bpPB, bpGB, m_caloMaterial,
                                         dummyLayers, dummyVolumes,
                                         "Calo::GapVolumes::Positive" + name);
    }
 
    Trk::TrackingVolume* bpSector = bpVolPos;
 
    if (bpVolGap) {
      std::vector<Trk::TrackingVolume*> gapVols;
      gapVols.push_back(bpVolPos);
      gapVols.push_back(bpVolGap);
      bpSector = m_trackingVolumeCreator->createContainerTrackingVolume(
          gapVols, m_caloMaterial, "Calo::Container::PositiveBPSector" + name);
    }
    posVols.push_back(bpSector);
  }
 
  Trk::TrackingVolume* bpPosSector =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          posVols, m_caloMaterial, "Calo::Container::PositiveBP" + name);
 
  // loop over z sections, prepare volumes for gluing
  std::vector<Trk::TrackingVolume*> negVols;
 
  for (unsigned int i = 0; i < dim.size() - 1; i++) {
 
    float zmax2 = -1. * (dim[i].second);
    float zmin2 = -1. * (dim[i + 1].second);
 
    if (zmin2 == zmax2)
      continue;
 
    // beam pipe volume
    Trk::CylinderVolumeBounds* bpBounds =
        new Trk::CylinderVolumeBounds(0., dim[i].first, 0.5 * (zmax2 - zmin2));
 
    Amg::Transform3D* bpNeg = new Amg::Transform3D(
        Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin2 + zmax2))));
 
    Trk::TrackingVolume* bpVolNeg =
        new Trk::TrackingVolume(bpNeg, bpBounds, m_caloMaterial, dummyLayers,
                                dummyVolumes, "BeamPipe::Negative" + name);
    bpVolNeg->sign(Trk::BeamPipe);
 
    Trk::TrackingVolume* bpVolGap =
        dim[i].first < outerRadius
            ? new Trk::TrackingVolume(
                  new Amg::Transform3D(*bpNeg),
                  new Trk::CylinderVolumeBounds(dim[i].first, outerRadius,
                                                0.5 * (zmax2 - zmin2)),
                  m_caloMaterial, dummyLayers, dummyVolumes,
                  "Calo::GapVolumes::Negative" + name)
            : nullptr;
 
    Trk::TrackingVolume* bpSector = bpVolNeg;
 
    if (bpVolGap) {
      std::vector<Trk::TrackingVolume*> gapVols;
      gapVols.push_back(bpVolNeg);
      gapVols.push_back(bpVolGap);
      bpSector = m_trackingVolumeCreator->createContainerTrackingVolume(
          gapVols, m_caloMaterial, "Calo::Container::NegativeBPSector" + name);
    }
 
    if (negVols.empty())
      negVols.push_back(bpSector);
    else
      negVols.insert(negVols.begin(), bpSector);
  }
 
  Trk::TrackingVolume* bpNegSector =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          negVols, m_caloMaterial, "Calo::Container::NegativeBP" + name);
 
  return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(bpPosSector,
                                                               bpNegSector);
}

createTrackingGeometry()

std::unique_ptr< Trk::TrackingGeometry > Calo::CaloTrackingGeometryBuilderImpl::createTrackingGeometry ( Trk::TrackingVolume *  innerVol, const CaloDetDescrManager *  caloDDM, const GeoAlignmentStore *  geoAlign  ) const

inherited

TrackingGeometry Interface method.

Definition at line 96 of file CaloTrackingGeometryBuilderImpl.cxx.

                                                                             {
 
  ATH_MSG_VERBOSE("Starting to build CaloTrackingGeometry ...");
 
  Trk::TrackingVolume* calorimeter = nullptr;
 
  // the key dimensions
  RZPairVector keyDim;
 
  // the enclosed input volume (ID)
  double enclosedInnerSectorHalflength = 0.;
  double enclosedInnerSectorRadius = 0.;
 
  // dummy objects
  Trk::LayerArray* dummyLayers = nullptr;
  Trk::TrackingVolumeArray* dummyVolumes = nullptr;
 
  if (innerVol) {
    ATH_MSG_VERBOSE("Got Inner Detector Volume: " << innerVol->volumeName());
    innerVol->screenDump(msg(MSG::VERBOSE));
 
    // retrieve dimensions
    const Trk::CylinderVolumeBounds* innerDetectorBounds =
        dynamic_cast<const Trk::CylinderVolumeBounds*>(
            &(innerVol->volumeBounds()));
    if (!innerDetectorBounds)
      std::abort();
 
    enclosedInnerSectorHalflength = innerDetectorBounds->halflengthZ();
    enclosedInnerSectorRadius = innerDetectorBounds->outerRadius();
 
    keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
  }
  // get the dimensions from the envelope service
  const RZPairVector& envelopeDefsIn =
      m_enclosingEnvelopeSvc->getCaloRZBoundary();
 
  // find the max,max pair
  unsigned int ii = 0;
  for (unsigned int i = 0; i < envelopeDefsIn.size(); i++) {
    if (envelopeDefsIn[i].second > envelopeDefsIn[ii].second)
      ii = i;
    else if (envelopeDefsIn[i].second == envelopeDefsIn[ii].second &&
             envelopeDefsIn[i].first > envelopeDefsIn[ii].first)
      ii = i;
  }
 
  // find the sense of rotation
  int irot = 1;
  unsigned int inext = ii + 1;
  if (inext == envelopeDefsIn.size())
    inext = 0;
  if (envelopeDefsIn[inext].second != envelopeDefsIn[ii].second) {
    irot = -1;
    inext = ii > 0 ? ii - 1 : envelopeDefsIn.size() - 1;
  }
 
  // fill starting with upper low edge, end with upper high edge
  RZPairVector envelopeDefs;
  if (irot > 0) {
    for (unsigned int i = inext; i < envelopeDefsIn.size(); i++)
      envelopeDefs.push_back(envelopeDefsIn[i]);
    if (inext > 0)
      for (unsigned int i = 0; i <= inext - 1; i++)
        envelopeDefs.push_back(envelopeDefsIn[i]);
  } else {
    int i = inext;
    while (i >= 0) {
      envelopeDefs.push_back(envelopeDefsIn[i]);
      i = i - 1;
    };
    inext = envelopeDefsIn.size() - 1;
    while (inext >= ii) {
      envelopeDefs.push_back(envelopeDefsIn[inext]);
      inext = inext - 1;
    };
  }
 
  double envEnclosingVolumeHalfZ = m_caloDefaultHalflengthZ;
 
  ATH_MSG_VERBOSE("Calo envelope definition retrieved:");
  RZPairVector msCutouts;
  for (unsigned int i = 0; i < envelopeDefs.size(); i++) {
    ATH_MSG_VERBOSE("Rz pair:" << i << ":" << envelopeDefs[i].first << ","
                               << envelopeDefs[i].second);
    if (std::abs(envelopeDefs[i].second) < envEnclosingVolumeHalfZ)
      envEnclosingVolumeHalfZ = std::abs(envelopeDefs[i].second);
    // ID dimensions : pick 1100 < R < 1200
    if (envelopeDefs[i].first > 1100. && envelopeDefs[i].first < 1200. &&
        envelopeDefs[i].second > 0.) {
      // check that radial size of ID envelope fits
      if (enclosedInnerSectorRadius != envelopeDefs[i].first)
        ATH_MSG_INFO(
            "Enclosed ID volume radius does not match ID envelope, adjusting "
            "Calo.");
      envEnclosingVolumeHalfZ = envelopeDefs[i].second;
      if (!innerVol) {
        enclosedInnerSectorRadius = envelopeDefs[i].first;
        enclosedInnerSectorHalflength = envelopeDefs[i].second;
      }
    }
    // collect outer cutouts, process those with |z| < 6785.mm ( this cut should
    // be synchronized with MS default size,
    //  MS builder would crash for a longer input volume )
    if (envelopeDefs[i].second > 0. && envelopeDefs[i].second < 6785. &&
        (envelopeDefs[i].first > 1200. ||
         envelopeDefs[i].second > envEnclosingVolumeHalfZ)) {
      if (msCutouts.empty())
        msCutouts.push_back(envelopeDefs[i]);
      else {
        RZPairVector::iterator envIter = msCutouts.begin();
        while (envIter != msCutouts.end() &&
               (*envIter).second < envelopeDefs[i].second)
          ++envIter;
        while (envIter != msCutouts.end() &&
               (*envIter).second == envelopeDefs[i].second &&
               (*envIter).first > envelopeDefs[i].first)
          ++envIter;
        msCutouts.insert(envIter, envelopeDefs[i]);
      }
    }
    // end outer (MS) cutouts
  }
  if (msgLvl(MSG::VERBOSE)) {
    for (unsigned int i = 0; i < msCutouts.size(); i++)
      ATH_MSG_VERBOSE("MS cutouts to be processed by Calo:"
                      << i << ":" << msCutouts[i].first << ","
                      << msCutouts[i].second);
  }
 
  // first member of msCutouts redefines the default central cylinder dimension
  double caloDefaultRadius = m_caloDefaultRadius;
  double caloDefaultHalflengthZ = m_caloDefaultHalflengthZ;
 
  if (!msCutouts.empty()) {
    caloDefaultRadius = msCutouts[0].first;
    caloDefaultHalflengthZ = msCutouts[0].second;
    ATH_MSG_VERBOSE(
        " Calo central cylinder dimensions adjusted using EnvelopeSvc:"
        << m_caloDefaultRadius << "," << m_caloDefaultHalflengthZ);
  }
 
  // create dummy ID if not built already
 
  if (!innerVol) {
    Trk::CylinderVolumeBounds* idBounds = new Trk::CylinderVolumeBounds(
        enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
 
    Amg::Transform3D* idTr = new Amg::Transform3D(Trk::s_idTransform);
 
    innerVol =
        new Trk::TrackingVolume(idTr, idBounds, m_caloMaterial, dummyLayers,
                                dummyVolumes, "Calo::GapVolumes::DummyID");
 
    keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
  }
 
  // BEAM PIPE
  const RZPairVector& bpDefs = m_enclosingEnvelopeSvc->getBeamPipeRZBoundary();
 
  ATH_MSG_VERBOSE("BeamPipe envelope definition retrieved:");
  RZPairVector bpCutouts;
  for (unsigned int i = 0; i < bpDefs.size(); i++) {
    ATH_MSG_VERBOSE("Rz pair:" << i << ":" << bpDefs[i].first << ","
                               << bpDefs[i].second);
    // beam pipe within calo : pick 10. < R < 200;  envEnclosingVolumeHalfZ   =<
    // z  <= msCutouts.back().second;
    if (bpDefs[i].first > 10. && bpDefs[i].first < 200. &&
        bpDefs[i].second >= envEnclosingVolumeHalfZ &&
        bpDefs[i].second <= msCutouts.back().second) {
      bpCutouts.push_back(bpDefs[i]);
    }
    if (i > 0 && i < 4)
      keyDim.push_back(bpDefs[i]);
  }
 
  // no beam pipe within ID
  // if (bpCutouts[0].second == envEnclosingVolumeHalfZ && bpCutouts[0].first >
  // 0 )  bpCutouts[0].first=0.;
  // last not needed
  if (bpCutouts.size() > 1 &&
      bpCutouts.back().second == bpCutouts[bpCutouts.size() - 2].second)
    bpCutouts.erase(bpCutouts.end() - 1);
  // end beam pipe envelope within Calo
  for (unsigned int i = 0; i < bpCutouts.size(); i++)
    ATH_MSG_VERBOSE("Beam pipe dimensions to be used by Calo:"
                    << i << ":" << bpCutouts[i].first << ","
                    << bpCutouts[i].second);
 
  keyDim.emplace_back(caloDefaultRadius, caloDefaultHalflengthZ);
 
 
  // PART 1 : Liquid Argon Volumes
  // ===========================================================================================
  // get the Tracking Volumes from the LAr Builder
  //
  const std::vector<Trk::TrackingVolume*>* lArVolumes =
    m_lArVolumeBuilder->trackingVolumes(*caloDDM,geoAlign);
 
  ATH_MSG_INFO(lArVolumes->size()
               << " volumes retrieved from " << m_lArVolumeBuilder.name());
 
  // LAr Barrel part
  Trk::TrackingVolume* solenoid = (*lArVolumes)[0];
  Trk::TrackingVolume* solenoidlArPresamplerGap = (*lArVolumes)[1];
  Trk::TrackingVolume* lArBarrelPresampler = (*lArVolumes)[2];
  Trk::TrackingVolume* lArBarrel = (*lArVolumes)[3];
 
  // LAr Positive Endcap part
  Trk::TrackingVolume* lArPositiveMBTS = (*lArVolumes)[4];
  Trk::TrackingVolume* lArPositiveEndcap = (*lArVolumes)[5];
  Trk::TrackingVolume* lArPositiveHec = (*lArVolumes)[6];
  Trk::TrackingVolume* lArPositiveFcal = (*lArVolumes)[7];
  Trk::TrackingVolume* lArPositiveHecFcalCover = (*lArVolumes)[8];
  // LAr Negative Endcap part
  Trk::TrackingVolume* lArNegativeMBTS = (*lArVolumes)[9];
  Trk::TrackingVolume* lArNegativeEndcap = (*lArVolumes)[10];
  Trk::TrackingVolume* lArNegativeHec = (*lArVolumes)[11];
  Trk::TrackingVolume* lArNegativeFcal = (*lArVolumes)[12];
  Trk::TrackingVolume* lArNegativeHecFcalCover = (*lArVolumes)[13];
  Trk::TrackingVolume* lArPosECPresampler = (*lArVolumes)[14];
  Trk::TrackingVolume* lArNegECPresampler = (*lArVolumes)[15];
 
  // PART 2 : Tile Volumes
  // ===========================================================================================
  // get the Tracking Volumes from the Tile Builder
  std::vector<Trk::TrackingVolume*>* tileVolumes =
    m_tileVolumeBuilder->trackingVolumes(*caloDDM,geoAlign);
 
  ATH_MSG_INFO(tileVolumes->size()
               << " volumes retrieved from " << m_tileVolumeBuilder.name());
  if (msgLvl(MSG::INFO)) {
    ATH_MSG_INFO(
        "--------------- detailed output "
        "---------------------------------------------------------- ");
    std::vector<Trk::TrackingVolume*>::const_iterator tileVolIter =
        tileVolumes->begin();
    std::vector<Trk::TrackingVolume*>::const_iterator tileVolIterEnd =
        tileVolumes->end();
    for (; tileVolIter != tileVolIterEnd;
         (*tileVolIter)->screenDump(msg(MSG::VERBOSE)), ++tileVolIter)
      ;
  }
 
  // Tile Barrel part
  Trk::TrackingVolume* tileCombined = (*tileVolumes)[0];
  // Tile Positive Extended Part
  Trk::TrackingVolume* tilePositiveExtendedBarrel = (*tileVolumes)[1];
 
  const Trk::CylinderVolumeBounds* ebBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(tilePositiveExtendedBarrel->volumeBounds()));
 
  double rTileMin = ebBounds ? ebBounds->innerRadius() : 2288.;
  double zTileMin = ebBounds ? tilePositiveExtendedBarrel->center().z() -
                                   ebBounds->halflengthZ()
                             : 3559.5;
 
  keyDim.emplace_back(rTileMin, zTileMin);
  for (unsigned int i = 0; i < keyDim.size(); i++) {
    ATH_MSG_VERBOSE("key dimensions:" << i << ":" << keyDim[i].first << ","
                                      << keyDim[i].second);
  }
 
  // The Bounds needed for the Gap Volume creation
  const Trk::CylinderVolumeBounds* solenoidBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(solenoid->volumeBounds()));
  if (!solenoidBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArBarrelBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArBarrel->volumeBounds()));
  if (!lArBarrelBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArPositiveEndcapBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArPositiveEndcap->volumeBounds()));
  if (!lArPositiveEndcapBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArNegativeEndcapBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArNegativeEndcap->volumeBounds()));
  if (!lArNegativeEndcapBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArPositiveHecBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArPositiveHec->volumeBounds()));
  if (!lArPositiveHecBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArPositiveFcalBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArPositiveFcal->volumeBounds()));
  if (!lArPositiveFcalBounds)
    std::abort();
  const Trk::CylinderVolumeBounds* lArNegativeFcalBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArNegativeFcal->volumeBounds()));
  if (!lArNegativeFcalBounds)
    std::abort();
 
  const Trk::CylinderVolumeBounds* tileCombinedBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(tileCombined->volumeBounds()));
  if (!tileCombinedBounds)
    std::abort();
 
  // Create the gap volumes
  // ======================================================================
  Trk::TrackingVolume* lArTileCentralSectorGap = nullptr;
 
  Trk::TrackingVolume* lArPositiveSectorInnerGap = nullptr;
  Trk::TrackingVolume* lArPositiveSectorOuterGap = nullptr;
  Trk::TrackingVolume* lArPositiveSectorOuterGap0 = nullptr;
  Trk::TrackingVolume* lArCentralPositiveGap = nullptr;
 
  Trk::TrackingVolume* lArNegativeSectorInnerGap = nullptr;
  Trk::TrackingVolume* lArNegativeSectorOuterGap = nullptr;
  Trk::TrackingVolume* lArNegativeSectorOuterGap0 = nullptr;
  Trk::TrackingVolume* lArCentralNegativeGap = nullptr;
 
  Trk::TrackingVolume* trtSolenoidGap = nullptr;
 
  double caloPositiveOuterBoundary = tileCombinedBounds->halflengthZ();
 
  double lArPositiveOuterBoundary = lArPositiveFcal->center().z();
  lArPositiveOuterBoundary += lArPositiveFcalBounds->halflengthZ();
 
  // No. 1
  // building dense volume here
  Trk::Material tilePositiveSectorInnerGapMaterial =
      Trk::Material(58., 565., 30.7, 14.6, 0.0025);
 
  // calo sensitive volume outer radius/z extent defined (for example) here
  float caloVolsOuterRadius = tileCombinedBounds->outerRadius();
  float caloVolsExtendZ = caloPositiveOuterBoundary;
 
  //  LAr InnerGap sector + beam pipe
 
  Trk::Material lArSectorInnerGapMaterial =
      Trk::Material(361., 1370., 14.5, 7., 0.0009);  // ???
 
  // create beam pipe volumes for InnerGap/MBTS and return their outer radius
  float rInnerGapBP = 0.;
  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> innerGapBP =
      createBeamPipeVolumes(
          bpCutouts, keyDim[0].second,
          // lArPositiveEndcap->center().z()-lArPositiveEndcapBounds->halflengthZ(),
          keyDim.back().second, "InnerGap", rInnerGapBP);
 
  double z = 0.5 * (keyDim.back().second + keyDim[0].second);
 
  auto mbtsNegLayers = std::make_unique<std::vector<Trk::Layer*>>();
  auto mbtsPosLayers = std::make_unique<std::vector<Trk::Layer*>>();
 
  if (lArPositiveMBTS && lArNegativeMBTS) {
    // Disc
    const Trk::CylinderVolumeBounds* mbtsBounds =
        dynamic_cast<const Trk::CylinderVolumeBounds*>(
            &(lArPositiveMBTS->volumeBounds()));
    if (mbtsBounds && m_buildMBTS) {
      float rmin = mbtsBounds->innerRadius();
      float rmax = mbtsBounds->outerRadius();
      // float d = mbtsBounds->halflengthZ();
      Trk::DiscBounds* dibo = new Trk::DiscBounds(rmin, rmax);
      // MBTS positions
      Amg::Transform3D mbtsNegZpos =
          Amg::Transform3D(Amg::Translation3D(lArNegativeMBTS->center()));
      Amg::Transform3D mbtsPosZpos =
          Amg::Transform3D(Amg::Translation3D(lArPositiveMBTS->center()));
      // create the two Layers ( TODO: add trd surface subarray )
      Trk::DiscLayer* mbtsNegLayer = new Trk::DiscLayer(
          mbtsNegZpos, dibo,
          // mbtsNegLayerSurfArray,
          Trk::HomogeneousLayerMaterial(
              Trk::MaterialProperties(m_caloMaterial, 1.), 1.),
          1.);
      Trk::DiscLayer* mbtsPosLayer = new Trk::DiscLayer(
          mbtsPosZpos, dibo->clone(),
          // mbtsPosLayerSurfArray,
          Trk::HomogeneousLayerMaterial(
              Trk::MaterialProperties(m_caloMaterial, 1.), 1.),
          1. * Gaudi::Units::mm);
 
      mbtsNegLayers->push_back(mbtsNegLayer);
      mbtsPosLayers->push_back(mbtsPosLayer);
    }
  }
 
  // building inner gap
  Trk::CylinderVolumeBounds* lArG1Bounds = new Trk::CylinderVolumeBounds(
      rInnerGapBP,
      // lArPositiveEndcapBounds->outerRadius(),
      keyDim[0].first, 0.5 * (keyDim.back().second - keyDim[0].second));
 
  Amg::Transform3D* lArG1P =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
  lArPositiveSectorInnerGap = new Trk::TrackingVolume(
      lArG1P, lArG1Bounds, lArSectorInnerGapMaterial, mbtsPosLayers.release(),
      "Calo::GapVolumes::LAr::PositiveSectorInnerGap");
 
  Amg::Transform3D* lArG1N =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
  lArNegativeSectorInnerGap = new Trk::TrackingVolume(
      lArG1N, lArG1Bounds->clone(), lArSectorInnerGapMaterial,
      mbtsNegLayers.release(), "Calo::GapVolumes::LAr::NegativeSectorInnerGap");
 
  // glue InnerGap with beam pipe volumes
  Trk::TrackingVolume* positiveInnerGap = nullptr;
  if (innerGapBP.first) {
    std::vector<Trk::TrackingVolume*> volsInnerGap;
    volsInnerGap.push_back(innerGapBP.first);
    volsInnerGap.push_back(lArPositiveSectorInnerGap);
    positiveInnerGap = m_trackingVolumeCreator->createContainerTrackingVolume(
        volsInnerGap, m_caloMaterial, "Calo::Container::PositiveInnerGap");
  } else
    positiveInnerGap = lArPositiveSectorInnerGap;
 
  Trk::TrackingVolume* negativeInnerGap = nullptr;
  if (innerGapBP.second) {
    std::vector<Trk::TrackingVolume*> volsInnerGap;
    volsInnerGap.push_back(innerGapBP.second);
    volsInnerGap.push_back(lArNegativeSectorInnerGap);
    negativeInnerGap = m_trackingVolumeCreator->createContainerTrackingVolume(
        volsInnerGap, m_caloMaterial, "Calo::Container::NegativeInnerGap");
  } else
    negativeInnerGap = lArNegativeSectorInnerGap;
 
  // glue MBTS volumes with ID
  std::vector<Trk::TrackingVolume*> inBufferVolumes;
  inBufferVolumes.push_back(negativeInnerGap);
  inBufferVolumes.push_back(innerVol);
  inBufferVolumes.push_back(positiveInnerGap);
 
  Trk::TrackingVolume* inDetEnclosed =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          inBufferVolumes, m_caloMaterial,
          "Calo::Container::EnclosedInnerDetector");
 
  ATH_MSG_DEBUG(" Inner detector enclosed (MBTS volumes)");
 
  // LAr endcap sector including the beam pipe
  // create beam pipe volumes for Endcap and return their outer radius
  float rEndcapBP = 0.;
  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> endcapBP =
      createBeamPipeVolumes(bpCutouts, keyDim.back().second,
                            lArPositiveEndcap->center().z() +
                                lArPositiveEndcapBounds->halflengthZ(),
                            "Endcap", rEndcapBP);
 
  // build lAr vessel around EC Presampler
  const Trk::CylinderVolumeBounds* ecpBounds =
      dynamic_cast<const Trk::CylinderVolumeBounds*>(
          &(lArPosECPresampler->volumeBounds()));
  if (!ecpBounds)
    std::abort();
 
  float ecpHz = ecpBounds->halflengthZ();
  float ecpRmin = ecpBounds->innerRadius();
  float ecpRmax = ecpBounds->outerRadius();
 
  Amg::Transform3D* ecpPos =
      new Amg::Transform3D(lArPosECPresampler->transform());
  Amg::Transform3D* ecpNeg =
      new Amg::Transform3D(lArNegECPresampler->transform());
 
  Trk::CylinderVolumeBounds* ecpUpBounds =
      new Trk::CylinderVolumeBounds(ecpRmax, keyDim.back().first, ecpHz);
  Trk::CylinderVolumeBounds* ecpDownBounds =
      new Trk::CylinderVolumeBounds(rEndcapBP, ecpRmin, ecpHz);
 
  Trk::TrackingVolume* ecPresamplerCoverPos = new Trk::TrackingVolume(
      ecpPos, ecpUpBounds, m_Al, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveECPresamplerCover");
  Trk::TrackingVolume* ecPresamplerCoverNeg = new Trk::TrackingVolume(
      ecpNeg, ecpUpBounds->clone(), m_Al, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::NegativeECPresamplerCover");
  Trk::TrackingVolume* ecPresamplerInnerPos = new Trk::TrackingVolume(
      new Amg::Transform3D(*ecpPos), ecpDownBounds, m_Al, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::PositiveECPresamplerInner");
  Trk::TrackingVolume* ecPresamplerInnerNeg = new Trk::TrackingVolume(
      new Amg::Transform3D(*ecpNeg), ecpDownBounds->clone(), m_Al, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::NegativeECPresamplerInner");
 
  // glue EC presampler radially
  std::vector<Trk::TrackingVolume*> volsECP;
  volsECP.push_back(ecPresamplerInnerPos);
  volsECP.push_back(lArPosECPresampler);
  volsECP.push_back(ecPresamplerCoverPos);
  Trk::TrackingVolume* positiveECP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsECP, m_caloMaterial, "Calo::Container::PositiveECPresamplerR");
  std::vector<Trk::TrackingVolume*> volsECN;
  volsECN.push_back(ecPresamplerInnerNeg);
  volsECN.push_back(lArNegECPresampler);
  volsECN.push_back(ecPresamplerCoverNeg);
  Trk::TrackingVolume* negativeECP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsECN, m_caloMaterial, "Calo::Container::NegativeECPresamplerR");
 
  // add surrounding buffers
  z = lArPosECPresampler->center().z() - ecpHz;
  float z1 = lArPosECPresampler->center().z() + ecpHz;
  float z2 =
      lArPositiveEndcap->center().z() - lArPositiveEndcapBounds->halflengthZ();
  Amg::Transform3D* ecIPos = new Amg::Transform3D(Amg::Translation3D(
      Amg::Vector3D(0., 0., 0.5 * (z + keyDim.back().second))));
  Amg::Transform3D* ecINeg = new Amg::Transform3D(Amg::Translation3D(
      Amg::Vector3D(0., 0., -0.5 * (z + keyDim.back().second))));
  Trk::CylinderVolumeBounds* ecpIBounds = new Trk::CylinderVolumeBounds(
      rEndcapBP, keyDim.back().first, 0.5 * (z - keyDim.back().second));
  Amg::Transform3D* ecOPos = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (z1 + z2))));
  Amg::Transform3D* ecONeg = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (z1 + z2))));
  Trk::CylinderVolumeBounds* ecpOBounds = new Trk::CylinderVolumeBounds(
      rEndcapBP, keyDim.back().first, 0.5 * (z2 - z1));
 
  Trk::TrackingVolume* ecPresamplerInPos = new Trk::TrackingVolume(
      ecIPos, ecpIBounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveECPresamplerIn");
  Trk::TrackingVolume* ecPresamplerInNeg = new Trk::TrackingVolume(
      ecINeg, ecpIBounds->clone(), m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::NegativeECPresamplerIn");
  Trk::TrackingVolume* ecPresamplerOutPos = new Trk::TrackingVolume(
      ecOPos, ecpOBounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveECPresamplerOut");
  Trk::TrackingVolume* ecPresamplerOutNeg = new Trk::TrackingVolume(
      ecONeg, ecpOBounds->clone(), m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::NegativeECPresamplerOut");
 
  // glue EC presampler in z
  std::vector<Trk::TrackingVolume*> volECP;
  volECP.push_back(ecPresamplerInPos);
  volECP.push_back(positiveECP);
  volECP.push_back(ecPresamplerOutPos);
  Trk::TrackingVolume* positiveEP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volECP, m_caloMaterial, "Calo::Container::PositiveECPresampler");
  std::vector<Trk::TrackingVolume*> volECN;
  volECN.push_back(ecPresamplerOutNeg);
  volECN.push_back(negativeECP);
  volECN.push_back(ecPresamplerInNeg);
  Trk::TrackingVolume* negativeEP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volECN, m_caloMaterial, "Calo::Container::NegativeECPresampler");
 
  // build lAr vessel around EMEC
  ecpHz = lArPositiveEndcapBounds->halflengthZ();
  ecpRmin = lArPositiveEndcapBounds->innerRadius();
  ecpRmax = lArPositiveEndcapBounds->outerRadius();
 
  Amg::Transform3D* ecPos =
      new Amg::Transform3D(lArPositiveEndcap->transform());
  Amg::Transform3D* ecNeg =
      new Amg::Transform3D(lArNegativeEndcap->transform());
 
  Trk::CylinderVolumeBounds* ecUpBounds =
      new Trk::CylinderVolumeBounds(ecpRmax, keyDim.back().first, ecpHz);
  Trk::CylinderVolumeBounds* ecDownBounds =
      new Trk::CylinderVolumeBounds(rEndcapBP, ecpRmin, ecpHz);
 
  Trk::TrackingVolume* ecCoverPos = new Trk::TrackingVolume(
      ecPos, ecUpBounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveEndcapCover");
  Trk::TrackingVolume* ecCoverNeg = new Trk::TrackingVolume(
      ecNeg, ecUpBounds->clone(), m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::NegativeEndcapCover");
  Trk::TrackingVolume* ecInnerPos = new Trk::TrackingVolume(
      new Amg::Transform3D(*ecPos), ecDownBounds, m_Al, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::PositiveEndcapInner");
  Trk::TrackingVolume* ecInnerNeg = new Trk::TrackingVolume(
      new Amg::Transform3D(*ecNeg), ecDownBounds->clone(), m_Al, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::NegativeEndcapInner");
 
  // glue EMEC radially
  std::vector<Trk::TrackingVolume*> volsEC;
  volsEC.push_back(ecInnerPos);
  volsEC.push_back(lArPositiveEndcap);
  volsEC.push_back(ecCoverPos);
  Trk::TrackingVolume* positiveEC =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsEC, m_caloMaterial, "Calo::Container::PositiveEndcapR");
  std::vector<Trk::TrackingVolume*> volsEN;
  volsEN.push_back(ecInnerNeg);
  volsEN.push_back(lArNegativeEndcap);
  volsEN.push_back(ecCoverNeg);
  Trk::TrackingVolume* negativeEC =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsEN, m_caloMaterial, "Calo::Container::NegativeEndcapR");
 
  // glue presampler with EMEC
  std::vector<Trk::TrackingVolume*> volEEP;
  volEEP.push_back(positiveEP);
  volEEP.push_back(positiveEC);
  Trk::TrackingVolume* positiveEEP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volEEP, m_caloMaterial, "Calo::Container::PositiveEMEC");
  std::vector<Trk::TrackingVolume*> volEEN;
  volEEN.push_back(negativeEC);
  volEEN.push_back(negativeEP);
  Trk::TrackingVolume* negativeEEP =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volEEN, m_caloMaterial, "Calo::Container::NegativeEMEC");
 
  // glue EMEC sector with beam pipe volumes
 
  std::vector<Trk::TrackingVolume*> volsEndcapPos;
  if (endcapBP.first)
    volsEndcapPos.push_back(endcapBP.first);
  volsEndcapPos.push_back(positiveEEP);
 
  std::unique_ptr<Trk::TrackingVolume> positiveEndcap(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsEndcapPos, m_caloMaterial, "Calo::Container::PositiveEndcap"));
 
  std::vector<Trk::TrackingVolume*> volsEndcapNeg;
  if (endcapBP.second)
    volsEndcapNeg.push_back(endcapBP.second);
  volsEndcapNeg.push_back(negativeEEP);
 
  std::unique_ptr<Trk::TrackingVolume> negativeEndcap(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsEndcapNeg, m_caloMaterial, "Calo::Container::NegativeEndcap"));
 
  // Hec sector + beam pipe + lAr cover
  // create beam pipe volumes for Hec and return their outer radius
  float rHecBP = 0.;
  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> hecBP =
      createBeamPipeVolumes(
          bpCutouts,
          lArPositiveHec->center().z() - lArPositiveHecBounds->halflengthZ(),
          lArPositiveHec->center().z() + lArPositiveHecBounds->halflengthZ(),
          "Hec", rHecBP);
  // HecInnerGap (new gap volume )
  Trk::Material lArHecInnerGapMaterial =
      Trk::Material(390., 1223., 18., 9., 0.0014);
 
  // create the Bounds
  Trk::CylinderVolumeBounds* lArHecInnerGapBounds =
      new Trk::CylinderVolumeBounds(rHecBP, lArPositiveHecBounds->innerRadius(),
                                    lArPositiveHecBounds->halflengthZ());
 
  Amg::Transform3D* lArHecPos = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveHec->center().z())));
  Amg::Transform3D* lArHecNeg = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeHec->center().z())));
 
  Trk::TrackingVolume* lArPositiveHecInnerGap = new Trk::TrackingVolume(
      lArHecPos, lArHecInnerGapBounds, m_Al, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveHecInnerGap");
 
  Trk::TrackingVolume* lArNegativeHecInnerGap = new Trk::TrackingVolume(
      lArHecNeg, lArHecInnerGapBounds->clone(), m_Al, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::NegativeHecInnerGap");
  // create the Bounds
  Trk::CylinderVolumeBounds* lArHecOuterGapBounds =
      new Trk::CylinderVolumeBounds(lArPositiveHecBounds->outerRadius(),
                                    keyDim.back().first,
                                    lArPositiveHecBounds->halflengthZ());
 
  Trk::TrackingVolume* lArPositiveHecOuterGap = new Trk::TrackingVolume(
      new Amg::Transform3D(*lArHecPos), lArHecOuterGapBounds, m_Ar, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::PositiveHecOuterGap");
 
  Trk::TrackingVolume* lArNegativeHecOuterGap = new Trk::TrackingVolume(
      new Amg::Transform3D(*lArHecNeg), lArHecOuterGapBounds->clone(), m_Ar,
      dummyLayers, dummyVolumes, "Calo::GapVolumes::LAr::NegativeHecOuterGap");
 
  // glue Hec sector with beam pipe volumes
 
  std::vector<Trk::TrackingVolume*> volsHecPos;
  if (hecBP.first)
    volsHecPos.push_back(hecBP.first);
  volsHecPos.push_back(lArPositiveHecInnerGap);
  volsHecPos.push_back(lArPositiveHec);
  volsHecPos.push_back(lArPositiveHecOuterGap);
 
  std::unique_ptr<Trk::TrackingVolume> positiveHec(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsHecPos, m_caloMaterial, "Calo::Container::PositiveHec"));
 
  std::vector<Trk::TrackingVolume*> volsHecNeg;
  if (hecBP.second)
    volsHecNeg.push_back(hecBP.second);
  volsHecNeg.push_back(lArNegativeHecInnerGap);
  volsHecNeg.push_back(lArNegativeHec);
  volsHecNeg.push_back(lArNegativeHecOuterGap);
 
  std::unique_ptr<Trk::TrackingVolume> negativeHec(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsHecNeg, m_caloMaterial, "Calo::Container::NegativeHec"));
 
  // Fcal sector + beam pipe + lAr cover
 
  // create beam pipe volumes for Fcal and return their outer radius
  float rFcalBP = 0.;
  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> fcalBP =
      createBeamPipeVolumes(
          bpCutouts,
          lArPositiveFcal->center().z() - lArPositiveFcalBounds->halflengthZ(),
          lArPositiveFcal->center().z() + lArPositiveFcalBounds->halflengthZ(),
          "Fcal", rFcalBP);
  // FcalInnerGap (new gap volume )
  // Trk::Material lArFcalInnerGapMaterial = Trk::Material(390.,
  // 1223., 40.,18., 0.0014);
 
  if (rFcalBP > lArPositiveFcalBounds->innerRadius()) {
    ATH_MSG_ERROR("PROBLEM : beam pipe collide with Fcal:"
                  << rFcalBP << ">" << lArPositiveFcalBounds->innerRadius()
                  << ", abort");
    return nullptr;
  }
 
  // create the Bounds
  Trk::CylinderVolumeBounds* lArFcalInnerGapBounds =
      new Trk::CylinderVolumeBounds(rFcalBP,
                                    lArPositiveFcalBounds->innerRadius(),
                                    lArPositiveFcalBounds->halflengthZ());
 
  Amg::Transform3D* lArFcalPos = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveFcal->center().z())));
  Amg::Transform3D* lArFcalNeg = new Amg::Transform3D(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeFcal->center().z())));
 
  Trk::TrackingVolume* lArPositiveFcalInnerGap = new Trk::TrackingVolume(
      lArFcalPos, lArFcalInnerGapBounds, m_Al, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveFcalInnerGap");
 
  Trk::TrackingVolume* lArNegativeFcalInnerGap = new Trk::TrackingVolume(
      lArFcalNeg, lArFcalInnerGapBounds->clone(), m_Al, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::NegativeFcalInnerGap");
 
  // create the Bounds
  Trk::CylinderVolumeBounds* lArFcalOuterGapBounds =
      new Trk::CylinderVolumeBounds(lArPositiveHecBounds->outerRadius(),
                                    keyDim.back().first,
                                    lArPositiveFcalBounds->halflengthZ());
 
  Trk::TrackingVolume* lArPositiveFcalOuterGap = new Trk::TrackingVolume(
      new Amg::Transform3D(*lArFcalPos), lArFcalOuterGapBounds, m_Ar,
      dummyLayers, dummyVolumes, "Calo::GapVolumes::LAr::PositiveFcalOuterGap");
 
  Trk::TrackingVolume* lArNegativeFcalOuterGap = new Trk::TrackingVolume(
      new Amg::Transform3D(*lArFcalNeg), lArFcalOuterGapBounds->clone(), m_Ar,
      dummyLayers, dummyVolumes, "Calo::GapVolumes::LAr::NegativeFcalOuterGap");
 
  // glue Fcal sector with beam pipe volumes
 
  std::vector<Trk::TrackingVolume*> volsFcalPos;
  if (fcalBP.first)
    volsFcalPos.push_back(fcalBP.first);
  volsFcalPos.push_back(lArPositiveFcalInnerGap);
  volsFcalPos.push_back(lArPositiveFcal);
  volsFcalPos.push_back(lArPositiveHecFcalCover);
  volsFcalPos.push_back(lArPositiveFcalOuterGap);
 
  std::unique_ptr<Trk::TrackingVolume> positiveFcal(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsFcalPos, m_caloMaterial, "Calo::Container::PositiveFcal"));
 
  std::vector<Trk::TrackingVolume*> volsFcalNeg;
  if (fcalBP.second)
    volsFcalNeg.push_back(fcalBP.second);
  volsFcalNeg.push_back(lArNegativeFcalInnerGap);
  volsFcalNeg.push_back(lArNegativeFcal);
  volsFcalNeg.push_back(lArNegativeHecFcalCover);
  volsFcalNeg.push_back(lArNegativeFcalOuterGap);
 
  std::unique_ptr<Trk::TrackingVolume> negativeFcal(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsFcalNeg, m_caloMaterial, "Calo::Container::NegativeFcal"));
 
  // Outer endcap sector + beam pipe
 
  // create beam pipe volumes for Outer sector and return their outer radius
  float rOutBP = 0.;
  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> outBP =
      createBeamPipeVolumes(bpCutouts, lArPositiveOuterBoundary,
                            caloPositiveOuterBoundary, "Outer", rOutBP);
 
  Trk::Material lArSectorOuterGapMat =
      Trk::Material(20.5, 723., 64., 28., 0.0084);
 
  Trk::CylinderVolumeBounds* lArSectorOuterG0Bounds =
      new Trk::CylinderVolumeBounds(
          rOutBP, 430.,
          // lArPositiveEndcapBounds->outerRadius(),
          0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
 
  Trk::CylinderVolumeBounds* lArSectorOuterG1Bounds =
      new Trk::CylinderVolumeBounds(
          430., keyDim.back().first,
          // lArPositiveEndcapBounds->outerRadius(),
          0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
 
  z = 0.5 * (caloPositiveOuterBoundary + lArPositiveOuterBoundary);
 
  Amg::Transform3D* lArSecOutG1P =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
  Amg::Transform3D* lArSecOutG0P =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  lArPositiveSectorOuterGap0 = new Trk::TrackingVolume(
      lArSecOutG0P, lArSectorOuterG0Bounds, lArSectorOuterGapMat, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::PositiveSectorOuterGap0");
 
  lArPositiveSectorOuterGap = new Trk::TrackingVolume(
      lArSecOutG1P, lArSectorOuterG1Bounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LAr::PositiveSectorOuterGap");
 
  Amg::Transform3D* lArSecOutG1N =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
  Amg::Transform3D* lArSecOutG0N =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  lArNegativeSectorOuterGap0 =
      new Trk::TrackingVolume(lArSecOutG0N, lArSectorOuterG0Bounds->clone(),
                              lArSectorOuterGapMat, dummyLayers, dummyVolumes,
                              "Calo::GapVolumes::LAr::NegativeSectorOuterGap0");
 
  lArNegativeSectorOuterGap = new Trk::TrackingVolume(
      lArSecOutG1N, lArSectorOuterG1Bounds->clone(), m_Ar, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LAr::NegativeSectorOuterGap");
 
  // glue OuterGap with beam pipe volumes
  std::vector<Trk::TrackingVolume*> volsOuterGapP;
  if (outBP.first)
    volsOuterGapP.push_back(outBP.first);
  volsOuterGapP.push_back(lArPositiveSectorOuterGap0);
  volsOuterGapP.push_back(lArPositiveSectorOuterGap);
  std::unique_ptr<Trk::TrackingVolume> positiveOuterGap(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsOuterGapP, m_caloMaterial, "Calo::Container::PositiveOuterGap"));
 
  std::vector<Trk::TrackingVolume*> volsOuterGapN;
  if (outBP.second)
    volsOuterGapN.push_back(outBP.second);
  volsOuterGapN.push_back(lArNegativeSectorOuterGap0);
  volsOuterGapN.push_back(lArNegativeSectorOuterGap);
  std::unique_ptr<Trk::TrackingVolume> negativeOuterGap(
      m_trackingVolumeCreator->createContainerTrackingVolume(
          volsOuterGapN, m_caloMaterial, "Calo::Container::NegativeOuterGap"));
 
  ATH_MSG_DEBUG("Endcap volumes ready");
 
  // ++ (ii) lArNegativeSector
  Trk::TrackingVolume* lArNegativeSector = nullptr;
  // +++ has 4 sub volumes in Z
  std::vector<Trk::TrackingVolume*> lArNegativeSectorVolumes;
  // +++ (A) -> Outer sector
  lArNegativeSectorVolumes.push_back(negativeOuterGap.release());
  // +++ (B) -> Fcal sector
  lArNegativeSectorVolumes.push_back(negativeFcal.release());
  // +++ (C) -> Hec sector
  lArNegativeSectorVolumes.push_back(negativeHec.release());
  // +++ (D) -> Endcap sector
  lArNegativeSectorVolumes.push_back(negativeEndcap.release());
  // +++ all exists : create super volume (ii)
  lArNegativeSector = m_trackingVolumeCreator->createContainerTrackingVolume(
      lArNegativeSectorVolumes, m_caloMaterial,
      "Calo::LAr::Container::NegativeSector");
 
  // ++ (ii) lArPositiveSector
  Trk::TrackingVolume* lArPositiveSector = nullptr;
  // +++ has 4 sub volumes in Z
  std::vector<Trk::TrackingVolume*> lArPositiveSectorVolumes;
  // +++ (A) -> Endcap sector
  lArPositiveSectorVolumes.push_back(positiveEndcap.release());
  // +++ (B) -> Hec sector
  lArPositiveSectorVolumes.push_back(positiveHec.release());
  // +++ (C) -> Fcal sector
  lArPositiveSectorVolumes.push_back(positiveFcal.release());
  // +++ (D) -> OuterGap
  lArPositiveSectorVolumes.push_back(positiveOuterGap.release());
  // +++ all exists : create super volume (ii)
  lArPositiveSector = m_trackingVolumeCreator->createContainerTrackingVolume(
      lArPositiveSectorVolumes, m_caloMaterial,
      "Calo::LAr::Container::PositiveSector");
 
  // central LAr barrel
  //
  // solenoid gap
  Trk::CylinderVolumeBounds* trtSolGapBounds = new Trk::CylinderVolumeBounds(
      keyDim[0].first, solenoidBounds->innerRadius(),
      solenoidBounds->halflengthZ());
 
  // solenoid gap is not completely empty
  Trk::Material solGapMat(535., 2871., 18.6, 9.1, 0.00038);
 
  trtSolenoidGap =
      new Trk::TrackingVolume(nullptr, trtSolGapBounds, solGapMat, dummyLayers,
                              dummyVolumes, "Calo::GapVolumes::SolenoidGap");
 
  Trk::CylinderVolumeBounds* lArTileCentralG1Bounds =
      new Trk::CylinderVolumeBounds(lArBarrelBounds->outerRadius(),
                                    tileCombinedBounds->innerRadius(),
                                    lArBarrelBounds->halflengthZ());
 
  lArTileCentralSectorGap = new Trk::TrackingVolume(
      nullptr, lArTileCentralG1Bounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LArTileCentralSectorGap");
 
  Trk::TrackingVolume* lArCentralBarrelSector = nullptr;
  // ++ has 6 sub volumes in R
  std::vector<Trk::TrackingVolume*> lArCentralBarrelSectorVolumes;
  // ++++ (a) -> solenoid gap
  lArCentralBarrelSectorVolumes.push_back(trtSolenoidGap);
  // ++++ (b) -> solenoid (exists already)
  lArCentralBarrelSectorVolumes.push_back(solenoid);
  // ++++ (c) -> solenoidlArPresamplerGap (exists already)
  lArCentralBarrelSectorVolumes.push_back(solenoidlArPresamplerGap);
  // ++++ (d) -> lArBarrelPresampler (exists already)
  lArCentralBarrelSectorVolumes.push_back(lArBarrelPresampler);
  // ++++ (e) -> lArBarrel (exists already)
  lArCentralBarrelSectorVolumes.push_back(lArBarrel);
  // ++++ (f) -> lArTile gap
  lArCentralBarrelSectorVolumes.push_back(lArTileCentralSectorGap);
  // ++++ all sub volumes exist: build the super volume
  lArCentralBarrelSector =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          lArCentralBarrelSectorVolumes, m_caloMaterial,
          "Calo::Containers::LAr::CentralBarrelSector", false, true);
  // side buffers
  // the Tile Crack volume (TileGap3, enum 17) inserted here
  // binned material for Crack : steering in binEta
  // TODO turn into 2D binned array
  std::vector<Trk::IdentifiedMaterial> matCrack;
  // layer material can be adjusted here
  int baseID = Trk::GeometrySignature(Trk::Calo) * 1000 + 17;
  matCrack.emplace_back(&m_Scint, baseID);
  matCrack.emplace_back(&m_caloMaterial, -1);
  matCrack.emplace_back(&m_Al, -1);
  //
  double etadist;
  // if TileGap3 goes above 1.6 in eta - it's RUN3 geometry
  int nbins =
      (caloDDM->is_in(1.65, 0.0, CaloCell_ID::TileGap3, etadist)) ? 6 : 3;
  Trk::BinUtility* bun =
      new Trk::BinUtility(nbins, -1.8, -1.2, Trk::open, Trk::binEta);
  Trk::BinUtility* bup =
      new Trk::BinUtility(nbins, 1.2, 1.8, Trk::open, Trk::binEta);
  // array of indices
  std::vector<std::vector<size_t>> indexP;
  std::vector<std::vector<size_t>> indexN;
  // binned material for LAr : layer depth per eta bin
  std::vector<Trk::BinUtility*> layDN(bun->bins());
  std::vector<Trk::BinUtility*> layUP(bup->bins());
  double crackZ1 = 3532.;
  double crackZ2 = 3540.;
  // construct bin utilities
  std::vector<float> steps;
  for (unsigned int i = 0; i < bup->bins(); i++) {
    steps.clear();
    std::vector<size_t> indx;
    indx.clear();
    steps.push_back(crackZ1);
    indx.push_back(i < bup->bins() - 1 ? 0 : 1);
    steps.push_back(crackZ2);
    indx.push_back(2);
    steps.push_back(keyDim.back().second);
    Trk::BinUtility* zBU = new Trk::BinUtility(steps, Trk::open, Trk::binZ);
    layUP[i] = zBU;
    indexP.push_back(indx);
  }
 
  const Trk::BinnedMaterial* crackBinPos =
      new Trk::BinnedMaterial(&m_crackMaterial, bup, layUP, indexP, matCrack);
 
  Amg::Transform3D* align = nullptr;
 
  Trk::CylinderVolumeBounds* crackBoundsPos = new Trk::CylinderVolumeBounds(
      keyDim[0].first, tileCombinedBounds->innerRadius(),
      0.5 * (keyDim.back().second - crackZ1));
  z = 0.5 * (keyDim.back().second + crackZ1);
  Amg::Transform3D* crackPosTransform =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  Trk::AlignableTrackingVolume* crackPos = new Trk::AlignableTrackingVolume(
      crackPosTransform, align, crackBoundsPos, crackBinPos, 17,
      "Calo::Detectors::Tile::CrackPos");
 
  for (unsigned int i = 0; i < bun->bins(); i++) {
    steps.clear();
    std::vector<size_t> indx;
    indx.clear();
    steps.push_back(-keyDim.back().second);
    indx.push_back(2);
    steps.push_back(-crackZ2);
    indx.push_back(i > 0 ? 0 : 1);
    steps.push_back(-crackZ1);
    Trk::BinUtility* zBU = new Trk::BinUtility(steps, Trk::open, Trk::binZ);
    layDN[i] = zBU;
    indexN.push_back(indx);
  }
 
  Trk::BinnedMaterial* crackBinNeg =
      new Trk::BinnedMaterial(&m_crackMaterial, bun, layDN, indexN, matCrack);
 
  align = nullptr;
 
  Amg::Transform3D* crackNegTransform =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  Trk::AlignableTrackingVolume* crackNeg = new Trk::AlignableTrackingVolume(
      crackNegTransform, align, crackBoundsPos->clone(), crackBinNeg, 17,
      "Calo::Detectors::Tile::CrackNeg");
 
  Trk::CylinderVolumeBounds* lArCentralG1Bounds = new Trk::CylinderVolumeBounds(
      keyDim[0].first, tileCombinedBounds->innerRadius(),
      0.5 * (crackZ1 - lArBarrelBounds->halflengthZ()));
 
  z = 0.5 * (crackZ1 + lArBarrelBounds->halflengthZ());
  Amg::Transform3D* lArCentralG1P =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  lArCentralPositiveGap = new Trk::TrackingVolume(
      lArCentralG1P, lArCentralG1Bounds, m_Ar, dummyLayers, dummyVolumes,
      "Calo::GapVolumes::LArCentralPositiveGap");
 
  Amg::Transform3D* lArCentralG1N =
      new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  lArCentralNegativeGap = new Trk::TrackingVolume(
      lArCentralG1N, lArCentralG1Bounds->clone(), m_Ar, dummyLayers,
      dummyVolumes, "Calo::GapVolumes::LArCentralNegativeGap");
 
  // glue laterally
  Trk::TrackingVolume* lArCentralSector = nullptr;
  // ++ has 5 sub volumes in z
  std::vector<Trk::TrackingVolume*> lArCentralSectorVolumes;
  // ++++ (a) -> negative crack
  lArCentralSectorVolumes.push_back(crackNeg);
  // ++++ (b) -> negative gap
  lArCentralSectorVolumes.push_back(lArCentralNegativeGap);
  // ++++ (c) -> central barrel
  lArCentralSectorVolumes.push_back(lArCentralBarrelSector);
  // ++++ (d) -> positive gap
  lArCentralSectorVolumes.push_back(lArCentralPositiveGap);
  // ++++ (e) -> positive crack
  lArCentralSectorVolumes.push_back(crackPos);
  // ++++ all sub volumes exist: build the super volume
  lArCentralSector = m_trackingVolumeCreator->createContainerTrackingVolume(
      lArCentralSectorVolumes, m_caloMaterial,
      "Calo::Containers::LAr::CentralSector");
 
  // glue with ID sector
  Trk::TrackingVolume* caloCentralSector = nullptr;
  // ++ has 2 sub volumes in R
  std::vector<Trk::TrackingVolume*> caloCentralSectorVolumes;
  // ++++ (a) -> ID sector
  caloCentralSectorVolumes.push_back(inDetEnclosed);
  // ++++ (b) -> LAr sector
  caloCentralSectorVolumes.push_back(lArCentralSector);
  // ++++ all sub volumes exist: build the super volume
  caloCentralSector = m_trackingVolumeCreator->createContainerTrackingVolume(
      caloCentralSectorVolumes, m_caloMaterial,
      "Calo::Containers::CaloCentralSector");
 
 
  // glue laterally with endcaps
  Trk::TrackingVolume* lArCombined = nullptr;
  // ++ has 3 sub volumes in z
  std::vector<Trk::TrackingVolume*> lArCombinedVolumes;
  // ++++ (a) -> negative endcap
  lArCombinedVolumes.push_back(lArNegativeSector);
  // ++++ (b) -> barrel
  lArCombinedVolumes.push_back(caloCentralSector);
  // ++++ (a) -> positive endcap
  lArCombinedVolumes.push_back(lArPositiveSector);
  // ++++ all sub volumes exist: build the super volume
  lArCombined = m_trackingVolumeCreator->createContainerTrackingVolume(
      lArCombinedVolumes, m_caloMaterial, "Calo::Containers::LAr::Combined");
 
  // glue with LAr sector
  Trk::TrackingVolume* caloCombined = nullptr;
  // ++ has 2 sub volumes in R
  std::vector<Trk::TrackingVolume*> caloVolumes;
  // ++++ (a) -> LAr sector
  caloVolumes.push_back(lArCombined);
  // ++++ (b) -> Tile sector
  caloVolumes.push_back(tileCombined);
  // ++++ all sub volumes exist: build the super volume
  caloCombined = m_trackingVolumeCreator->createContainerTrackingVolume(
      caloVolumes, m_caloMaterial, "Calo::Containers::CombinedCalo");
 
 
  // build the radial buffer volume to synchronize the radial envelope
  // dimensions
  Trk::TrackingVolume* centralBuffer = nullptr;
  Trk::TrackingVolume* ecPosBuffer = nullptr;
  Trk::TrackingVolume* ecNegBuffer = nullptr;
 
  if (caloVolsOuterRadius > caloDefaultRadius) {
    ATH_MSG_VERBOSE(
        "Calo volumes exceeds envelope radius: adjusting envelope "
        "(de-synchronizing...)");
    caloDefaultRadius = caloVolsOuterRadius;
  }
 
  if (caloVolsOuterRadius < caloDefaultRadius) {
    ATH_MSG_VERBOSE(
        "Build radial buffer to synchronize the boundaries in between R "
        << caloVolsOuterRadius << " and " << caloDefaultRadius);
 
    Trk::CylinderVolumeBounds* centralSynBounds = new Trk::CylinderVolumeBounds(
        caloVolsOuterRadius, caloDefaultRadius, caloVolsExtendZ);
    centralBuffer = new Trk::TrackingVolume(
        nullptr, centralSynBounds, m_caloMaterial, dummyLayers, dummyVolumes,
        "Calo::GapVolumes::EnvelopeBuffer");
  }
 
  if (caloVolsExtendZ < caloDefaultHalflengthZ) {
    ATH_MSG_VERBOSE(
        "Build longitudinal buffers to synchronize the boundaries in between Z "
        << caloVolsExtendZ << " and " << caloDefaultHalflengthZ);
 
    Trk::CylinderVolumeBounds* endcapSynBounds = new Trk::CylinderVolumeBounds(
        0., caloDefaultRadius,
        0.5 * (caloDefaultHalflengthZ - caloVolsExtendZ));
    // endcap buffers not empty
    Trk::Material ecBuffMat(53. / 0.38, 355. / 0.38, 20., 10.,
                            0.0053 * pow(0.38, 3));
 
    float zPos = 0.5 * (caloDefaultHalflengthZ + caloVolsExtendZ);
    ecPosBuffer = new Trk::TrackingVolume(
        new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., zPos))),
        endcapSynBounds, m_Ar, dummyLayers, dummyVolumes,
        "Calo::GapVolumes::PosECBuffer");
 
    ecNegBuffer = new Trk::TrackingVolume(
        new Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -zPos))),
        endcapSynBounds->clone(), m_Ar, dummyLayers, dummyVolumes,
        "Calo::GapVolumes::NegECBuffer");
  }
 
  ATH_MSG_VERBOSE(
      "All gap volumes for the Calorimeter created. Starting to build Volume "
      "Hiearchy.");
 
 
  ATH_MSG_VERBOSE("Resolve MS cutouts:");
 
  // resolve number of additional cutout volumes
  int nCutVol = 0;
  std::vector<float> zCutStep;
  std::vector<float> rCutStep;
  if (msCutouts.size() > 1) {
    zCutStep.push_back(msCutouts[0].second);
    rCutStep.push_back(msCutouts[0].first);
    for (unsigned int i = 1; i < msCutouts.size(); i++) {
      if (msCutouts[i].second == zCutStep.back())
        rCutStep.push_back(msCutouts[i].first);
      else
        zCutStep.push_back(msCutouts[i].second);
    }
    nCutVol = zCutStep.size() - 1;
  }
  if (nCutVol > 0)
    ATH_MSG_VERBOSE(nCutVol << " MS cutout volume(s) required ");
 
  std::vector<Trk::TrackingVolume*> forwardCutoutVols;
  std::vector<Trk::TrackingVolume*> backwardCutoutVols;
 
  // cutout region not empty
  std::vector<Trk::Material> cutOutMat;
  cutOutMat.emplace_back(19.9, 213., 50., 23.,
                         0.0065);  // 3.5 Fe + 1 Ar : verify
  cutOutMat.push_back(m_caloMaterial);
  // cutOutMat.push_back(Trk::Material(18.74, 200.9, 52.36, 24.09, 0.0069));
 
  if (nCutVol > 0) {
    // loop over zCutStep, rCutStep[0] gives the fixed outer radius, rCutStep[i]
    // the cutout radius for ith volume
    float rout = rCutStep[0];
    float zlow = zCutStep[0];
    for (unsigned int i = 1; i < zCutStep.size(); i++) {
      float zup = zCutStep[i];
      float rcut = rCutStep[i];
      std::stringstream ss;
      ss << i;
      // get beam pipe volumes
      float rCutOutBP = 0.;
      std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> cutOutBP =
          createBeamPipeVolumes(bpCutouts, zlow, zup, "CutOuts" + ss.str(),
                                rCutOutBP);
 
      // build inner part ( -> Calo )
      unsigned int mindex = i > 1 ? 1 : i;
 
      Trk::CylinderVolumeBounds* cutInBounds =
          new Trk::CylinderVolumeBounds(rCutOutBP, rcut, 0.5 * (zup - zlow));
      Trk::TrackingVolume* caloInPos = new Trk::TrackingVolume(
          new Amg::Transform3D(
              Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
          cutInBounds, cutOutMat[mindex], dummyLayers, dummyVolumes,
          "Calo::GapVolumes::CaloPositiveCutIn" + ss.str());
      Trk::TrackingVolume* caloInNeg = new Trk::TrackingVolume(
          new Amg::Transform3D(
              Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
          cutInBounds->clone(), cutOutMat[mindex], dummyLayers, dummyVolumes,
          "Calo::GapVolumes::CaloNegativeCutIn" + ss.str());
      // build cutout ( -> MS ) : geometry signature needs to be resolved later
      // : follow naming convention
      Trk::CylinderVolumeBounds* cutOutBounds =
          new Trk::CylinderVolumeBounds(rcut, rout, 0.5 * (zup - zlow));
      Trk::TrackingVolume* caloOutPos = new Trk::TrackingVolume(
          new Amg::Transform3D(
              Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
          cutOutBounds, m_caloMaterial, dummyLayers, dummyVolumes,
          "Muon::GapVolumes::CaloPositiveCutOut" + ss.str());
      Trk::TrackingVolume* caloOutNeg = new Trk::TrackingVolume(
          new Amg::Transform3D(
              Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
          cutOutBounds->clone(), m_caloMaterial, dummyLayers, dummyVolumes,
          "Muon::GapVolumes::CaloNegativeCutOut" + ss.str());
 
      // sign
      caloOutPos->sign(Trk::MS);
      caloOutNeg->sign(Trk::MS);
 
      // glue radially and save for final gluing
      std::vector<Trk::TrackingVolume*> cvPos;
      cvPos.push_back(cutOutBP.first);
      cvPos.push_back(caloInPos);
      cvPos.push_back(caloOutPos);
      Trk::TrackingVolume* cutOutPos =
          m_trackingVolumeCreator->createContainerTrackingVolume(
              cvPos, m_caloMaterial,
              "Calo::GapVolumes::CaloPositiveCutoutVolume" + ss.str());
      forwardCutoutVols.push_back(cutOutPos);
      //
      std::vector<Trk::TrackingVolume*> cvNeg;
      cvNeg.push_back(cutOutBP.second);
      cvNeg.push_back(caloInNeg);
      cvNeg.push_back(caloOutNeg);
      Trk::TrackingVolume* cutOutNeg =
          m_trackingVolumeCreator->createContainerTrackingVolume(
              cvNeg, m_caloMaterial,
              "Calo::GapVolumes::CaloNegativeCutoutVolume" + ss.str());
      backwardCutoutVols.insert(backwardCutoutVols.begin(), cutOutNeg);
 
      zlow = zup;
    }
  }
 
 
  if (!centralBuffer) {  //(XX)
    // all volumes exist : create the super volume at top level
    calorimeter = caloCombined;
 
  } else {  //(X)
 
    std::vector<Trk::TrackingVolume*> envRVols;
    envRVols.push_back(caloCombined);
    envRVols.push_back(centralBuffer);
 
    // add cutouts - final step
    if (!forwardCutoutVols.empty() || ecNegBuffer) {
 
      Trk::TrackingVolume* caloRVolume =
          m_trackingVolumeCreator->createContainerTrackingVolume(
              envRVols, m_caloMaterial, "Calo::Containers::CombinedRCalo");
      std::vector<Trk::TrackingVolume*> envZVols;
      envZVols.reserve(backwardCutoutVols.size());
      for (auto& backwardCutoutVol : backwardCutoutVols)
        envZVols.push_back(backwardCutoutVol);
      if (ecNegBuffer)
        envZVols.push_back(ecNegBuffer);
      envZVols.push_back(caloRVolume);
      if (ecPosBuffer)
        envZVols.push_back(ecPosBuffer);
      for (auto& forwardCutoutVol : forwardCutoutVols)
        envZVols.push_back(forwardCutoutVol);
 
      calorimeter = m_trackingVolumeCreator->createContainerTrackingVolume(
          envZVols, m_caloMaterial, m_exitVolume);
 
    } else {  // if no cutouts or endcap buffers, this is the top calo volume
 
      calorimeter = m_trackingVolumeCreator->createContainerTrackingVolume(
          envRVols, m_caloMaterial, m_exitVolume);
    }
  }
 
  ATH_MSG_VERBOSE(
      "TrackingVolume 'Calorimeter' built successfully. Wrap it in "
      "TrackingGeometry.");
 
  delete lArVolumes;
  lArVolumes = nullptr;
  delete tileVolumes;
  tileVolumes = nullptr;
 
  auto caloTrackingGeometry =
      std::make_unique<Trk::TrackingGeometry>(calorimeter);
 
  if (msgLvl(MSG::VERBOSE) && caloTrackingGeometry){
    caloTrackingGeometry->printVolumeHierarchy(msg(MSG::VERBOSE));
  }
 
  if (m_indexStaticLayers && caloTrackingGeometry){
    caloTrackingGeometry->indexStaticLayers(signature());
  }
 
  return caloTrackingGeometry;
}

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

DeclareInterfaceID()

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

inherited

Creates the InterfaceID and interfaceID() method.

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

geometrySignature()

virtual Trk::GeometrySignature Calo::CaloTrackingGeometryBuilder::geometrySignature ( ) const

inlinefinaloverridevirtual

The unique signature.

Implements Trk::IGeometryBuilder.

Definition at line 46 of file CaloTrackingGeometryBuilder.h.

                                                                        {
    return CaloTrackingGeometryBuilderImpl::signature();
  }

initialize()

StatusCode Calo::CaloTrackingGeometryBuilder::initialize ( )

overridevirtual

AlgTool initailize method.

Reimplemented from Calo::CaloTrackingGeometryBuilderImpl.

Definition at line 23 of file CaloTrackingGeometryBuilder.cxx.

                                                       {
  return Calo::CaloTrackingGeometryBuilderImpl::initialize();
}

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.

registerInLayerIndexCaloSampleMap()

void Calo::CaloTrackingGeometryBuilderImpl::registerInLayerIndexCaloSampleMap ( Trk::LayerIndexSampleMap &  licsMAp, const std::vector< CaloCell_ID::CaloSample > &  ccid, const Trk::TrackingVolume &  vol, int  side = 1  ) const

protectedinherited

method to establish a link between the LayerIndex and the CaloCell_ID in an associative container

Definition at line 1420 of file CaloTrackingGeometryBuilderImpl.cxx.

                    {
 
  ATH_MSG_VERBOSE("[+] Registering layers of TrackingVolume '"
                  << vol.volumeName() << "' in LayerIndex/CaloCell_ID map");
 
  // get the confined Layers from the TrackingVolume
  const Trk::LayerArray* confinedLayers = vol.confinedLayers();
  if (!confinedLayers)
    return;
 
  Trk::BinnedArraySpan<Trk::Layer const* const> layerObjects =
      confinedLayers->arrayObjects();
  Trk::BinnedArraySpan<Trk::Layer const* const>::iterator layerObjIter =
      layerObjects.begin();
  Trk::BinnedArraySpan<Trk::Layer const* const>::iterator layerObjEnd =
      layerObjects.end();
 
  // now pick out the material layers (and skip the navigation ones)
  std::vector<const Trk::Layer*> materialLayers;
  for (; layerObjIter != layerObjEnd; ++layerObjIter)
    if ((*layerObjIter)->layerMaterialProperties())
      materialLayers.push_back((*layerObjIter));
 
  unsigned int matLaySize = materialLayers.size();
  unsigned int ccidSize = ccid.size();
 
  ATH_MSG_VERBOSE("[+] Found " << matLaySize << " material layers ( "
                               << ccidSize << " CaloSample ids )");
  if (matLaySize != ccidSize)
    return;
 
  // everything's fine for side > 0
  if (side > 0) {
    // match 1-to-1
    std::vector<const Trk::Layer*>::const_iterator layerIt = materialLayers.begin();
    std::vector<const Trk::Layer*>::const_iterator layerItEnd = materialLayers.end();
    std::vector<CaloCell_ID::CaloSample>::const_iterator ccidIt = ccid.begin();
    std::vector<CaloCell_ID::CaloSample>::const_iterator ccidItEnd = ccid.end();
 
    for (; layerIt != layerItEnd && ccidIt != ccidItEnd; ++layerIt, ++ccidIt)
      licsMap.insert(std::make_pair((*layerIt)->layerIndex(), int(*ccidIt)));
 
  } else {
    // the order needs to be reversed, because TG has z-ordering positive
    // defined
 
    std::vector<CaloCell_ID::CaloSample>::const_iterator ccidIt = ccid.begin();
    std::vector<CaloCell_ID::CaloSample>::const_iterator ccidItEnd = ccid.end();
 
    for (; ccidIt != ccidItEnd; ++ccidIt, --matLaySize)
      licsMap.insert(std::make_pair(
          (materialLayers[matLaySize - 1])->layerIndex(), int(*ccidIt)));
  }
}

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

signature()

Trk::GeometrySignature Calo::CaloTrackingGeometryBuilderImpl::signature ( ) const

inlineinherited

The unique signature.

Definition at line 65 of file CaloTrackingGeometryBuilderImpl.h.

                                         {
    return Trk::Calo;
  }

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.

trackingGeometry()

std::unique_ptr< Trk::TrackingGeometry > Calo::CaloTrackingGeometryBuilder::trackingGeometry ( Trk::TrackingVolume *  tvol = 0 ) const

overridevirtual

TrackingGeometry Interface methode.

Implements Trk::IGeometryBuilder.

Definition at line 27 of file CaloTrackingGeometryBuilder.cxx.

                                       {
 
  std::unique_ptr<Trk::TrackingGeometry> trackingGeometry{};
 
  const CaloDetDescrManager* caloDDM =
      detStore()->tryConstRetrieve<CaloDetDescrManager>(caloMgrStaticKey);
  if (!caloDDM) {
    std::unique_ptr<CaloDetDescrManager> caloMgrPtr =
        buildCaloDetDescrNoAlign(serviceLocator(), Athena::getMessageSvc());
    if (detStore()->record(std::move(caloMgrPtr), caloMgrStaticKey) !=
        StatusCode::SUCCESS) {
      ATH_MSG_WARNING("Failed to record CaloDetDescrManager with the key "
                      << caloMgrStaticKey << " in DetStore");
      return trackingGeometry;
    }
    if (detStore()->retrieve(caloDDM, caloMgrStaticKey) !=
        StatusCode::SUCCESS) {
      ATH_MSG_WARNING("Failed to retrieve CaloDetDescrManager with the key "
                      << caloMgrStaticKey << " from DetStore");
      return trackingGeometry;
    }
  }
  // if caloDD is still null, we;re in trouble because it gets dereferenced
  // after this
  if (!caloDDM) {
    ATH_MSG_WARNING("caloDDM is a null pointer in CaloTrackingGeometryBuilder");
    return trackingGeometry;
  }
  return Calo::CaloTrackingGeometryBuilderImpl::createTrackingGeometry(innerVol,
                                                                       caloDDM,
                                       nullptr);
}

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_Al

Trk::Material Calo::CaloTrackingGeometryBuilderImpl::m_Al {88.93, 388.62, 26.98, 13., 0.0027}

protectedinherited

Definition at line 89 of file CaloTrackingGeometryBuilderImpl.h.

m_Ar

Trk::Material Calo::CaloTrackingGeometryBuilderImpl::m_Ar {140.036, 856.32, 39.948, 18., 0.0014}

protectedinherited

Definition at line 88 of file CaloTrackingGeometryBuilderImpl.h.

m_buildMBTS

BooleanProperty Calo::CaloTrackingGeometryBuilderImpl::m_buildMBTS {this, "BuildMBTS", true}

protectedinherited

MBTS like detectors.

Definition at line 106 of file CaloTrackingGeometryBuilderImpl.h.

m_caloDefaultHalflengthZ

DoubleProperty Calo::CaloTrackingGeometryBuilderImpl::m_caloDefaultHalflengthZ {this, "CalorimeterHalflengthZ", 6500.}

protectedinherited

the halflength in z if not built from

GeoModel

Definition at line 98 of file CaloTrackingGeometryBuilderImpl.h.

m_caloDefaultRadius

DoubleProperty Calo::CaloTrackingGeometryBuilderImpl::m_caloDefaultRadius {this, "CalorimeterRadius", 4250.}

protectedinherited

the radius if not built from GeoModel

Definition at line 97 of file CaloTrackingGeometryBuilderImpl.h.

m_caloEnvelope

DoubleProperty Calo::CaloTrackingGeometryBuilderImpl::m_caloEnvelope {this, "GapLayerEnvelope", 25 * Gaudi::Units::mm}

protectedinherited

Envelope cover for Gap Layers.

Definition at line 93 of file CaloTrackingGeometryBuilderImpl.h.

m_caloMaterial

Trk::Material Calo::CaloTrackingGeometryBuilderImpl::m_caloMaterial {}

protectedinherited

Definition at line 87 of file CaloTrackingGeometryBuilderImpl.h.

m_crackMaterial

Trk::Material Calo::CaloTrackingGeometryBuilderImpl::m_crackMaterial {424.35, 707.43, 11.16, 5.61, 0.001}

protectedinherited

Definition at line 91 of file CaloTrackingGeometryBuilderImpl.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_enclosingEnvelopeSvc

ServiceHandle<IEnvelopeDefSvc> Calo::CaloTrackingGeometryBuilderImpl::m_enclosingEnvelopeSvc {this, "EnvelopeDefinitionSvc", "AtlasGeometry_EnvelopeDefSvc"}

protectedinherited

Definition at line 95 of file CaloTrackingGeometryBuilderImpl.h.

m_entryVolume

StringProperty Calo::CaloTrackingGeometryBuilderImpl::m_entryVolume {this, "EntryVolumeName", "Calo::Container::EntryVolume"}

protectedinherited

name of the Calo entrance

Definition at line 114 of file CaloTrackingGeometryBuilderImpl.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_exitVolume

StringProperty Calo::CaloTrackingGeometryBuilderImpl::m_exitVolume {this, "ExitVolumeName", "Calo::Container"}

protectedinherited

name of the Calo container

Definition at line 115 of file CaloTrackingGeometryBuilderImpl.h.

m_indexStaticLayers

BooleanProperty Calo::CaloTrackingGeometryBuilderImpl::m_indexStaticLayers {this, "IndexStaticLayers", true}

protectedinherited

forces robust indexing for layers

Definition at line 101 of file CaloTrackingGeometryBuilderImpl.h.

m_lArVolumeBuilder

PublicToolHandle<Trk::ICaloTrackingVolumeBuilder> Calo::CaloTrackingGeometryBuilderImpl::m_lArVolumeBuilder {this, "LArVolumeBuilder", "LAr::LArVolumeBuilder/LArVolumeBuilder"}

protectedinherited

Volume Builder for the Tile Calorimeter.

Definition at line 82 of file CaloTrackingGeometryBuilderImpl.h.

m_layerIndexCaloSampleMapName

StringProperty Calo::CaloTrackingGeometryBuilderImpl::m_layerIndexCaloSampleMapName {this, "LayerIndexCaloSampleMapName", "LayerIndexCaloSampleMap"}

protectedinherited

name to record it

Definition at line 104 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsPhiGap

std::vector<double> Calo::CaloTrackingGeometryBuilderImpl::m_mbtsPhiGap

protectedinherited

MBTS like detectors.

Definition at line 110 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsPhiSegments

std::vector<int> Calo::CaloTrackingGeometryBuilderImpl::m_mbtsPhiSegments

protectedinherited

MBTS like detectors.

Definition at line 109 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsPositionZ

std::vector<double> Calo::CaloTrackingGeometryBuilderImpl::m_mbtsPositionZ

protectedinherited

MBTS like detectors.

Definition at line 111 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsRadiusGap

std::vector<double> Calo::CaloTrackingGeometryBuilderImpl::m_mbtsRadiusGap

protectedinherited

MBTS like detectors.

Definition at line 108 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsStaggeringZ

std::vector<double> Calo::CaloTrackingGeometryBuilderImpl::m_mbtsStaggeringZ

protectedinherited

MBTS like detectors.

Definition at line 112 of file CaloTrackingGeometryBuilderImpl.h.

m_recordLayerIndexCaloSampleMap

BooleanProperty Calo::CaloTrackingGeometryBuilderImpl::m_recordLayerIndexCaloSampleMap {this, "RecordLayerIndexCaloSampleMap", true}

protectedinherited

for deposition methods

Definition at line 103 of file CaloTrackingGeometryBuilderImpl.h.

m_Scint

Trk::Material Calo::CaloTrackingGeometryBuilderImpl::m_Scint {424.35, 707.43, 11.16, 5.61, 0.001}

protectedinherited

Definition at line 90 of file CaloTrackingGeometryBuilderImpl.h.

m_tileVolumeBuilder

PublicToolHandle<Trk::ICaloTrackingVolumeBuilder> Calo::CaloTrackingGeometryBuilderImpl::m_tileVolumeBuilder {this, "TileVolumeBuilder", "Tile::TileVolumeBuilder/TileVolumeBuilder"}

protectedinherited

Material properties.

Definition at line 84 of file CaloTrackingGeometryBuilderImpl.h.

m_trackingVolumeArrayCreator

PublicToolHandle<Trk::ITrackingVolumeArrayCreator> Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}

protectedinherited

Helper Tool to create TrackingVolumes.

Definition at line 76 of file CaloTrackingGeometryBuilderImpl.h.

m_trackingVolumeCreator

PublicToolHandle<Trk::ITrackingVolumeCreator> Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeCreator {this, "TrackingVolumeCreator", "Trk::CylinderVolumeCreator/TrackingVolumeCreator"}

protectedinherited

Volume Builder for the Liquid Argon Calorimeter.

Definition at line 80 of file CaloTrackingGeometryBuilderImpl.h.

m_trackingVolumeHelper

PublicToolHandle<Trk::ITrackingVolumeHelper> Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeHelper {this, "TrackingVolumeHelper", "Trk::TrackingVolumeHelper/TrackingVolumeHelper"}

protectedinherited

Second helper for volume creation.

Definition at line 78 of file CaloTrackingGeometryBuilderImpl.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:

• CaloTrackingGeometryBuilder.h
• CaloTrackingGeometryBuilder.cxx