Calo::CaloTrackingGeometryBuilderImpl Class Reference

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

#include <CaloTrackingGeometryBuilderImpl.h>

Inheritance diagram for Calo::CaloTrackingGeometryBuilderImpl:

Collaboration diagram for Calo::CaloTrackingGeometryBuilderImpl:

Public Member Functions
virtual	~CaloTrackingGeometryBuilderImpl ()
	Destructor.
virtual StatusCode	initialize () override
	AlgTool initailize method.
std::unique_ptr< Trk::TrackingGeometry >	createTrackingGeometry (Trk::TrackingVolume *innerVol, const CaloDetDescrManager *caloDDM, const GeoAlignmentStore *geoAlign) const
	TrackingGeometry Interface method.
Trk::GeometrySignature	signature () const
	The unique signature.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
	CaloTrackingGeometryBuilderImpl (const std::string &, const std::string &, const IInterface *)
	Constructor.
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
std::pair< Trk::TrackingVolume *, Trk::TrackingVolume * >	createBeamPipeVolumes (const RZPairVector &bpCutouts, float, float, const std::string &, float &) const
	method to build enclosed beam pipe volumes
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
PublicToolHandle< Trk::ITrackingVolumeArrayCreator >	m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}
	Second helper for volume creation.
PublicToolHandle< Trk::ITrackingVolumeCreator >	m_trackingVolumeCreator {this, "TrackingVolumeCreator", "Trk::CylinderVolumeCreator/TrackingVolumeCreator"}
	Volume Builder for the Liquid Argon Calorimeter.
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder >	m_lArVolumeBuilder {this, "LArVolumeBuilder", "LAr::LArVolumeBuilder/LArVolumeBuilder"}
	Volume Builder for the Tile Calorimeter.
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder >	m_tileVolumeBuilder {this, "TileVolumeBuilder", "Tile::TileVolumeBuilder/TileVolumeBuilder"}
	Material properties.
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.
ServiceHandle< IEnvelopeDefSvc >	m_enclosingEnvelopeSvc {this, "EnvelopeDefinitionSvc", "AtlasGeometry_EnvelopeDefSvc"}
DoubleProperty	m_caloDefaultRadius {this, "CalorimeterRadius", 4250.}
	the radius if not built from GeoModel
DoubleProperty	m_caloDefaultHalflengthZ {this, "CalorimeterHalflengthZ", 6500.}
	the halflength in z if not built from
BooleanProperty	m_indexStaticLayers {this, "IndexStaticLayers", true}
	forces robust indexing for layers
BooleanProperty	m_recordLayerIndexCaloSampleMap {this, "RecordLayerIndexCaloSampleMap", true}
	for deposition methods
StringProperty	m_layerIndexCaloSampleMapName {this, "LayerIndexCaloSampleMapName", "LayerIndexCaloSampleMap"}
	name to record it
BooleanProperty	m_buildMBTS {this, "BuildMBTS", true}
	MBTS like detectors.
std::vector< double >	m_mbtsRadiusGap
	MBTS like detectors.
std::vector< int >	m_mbtsPhiSegments
	MBTS like detectors.
std::vector< double >	m_mbtsPhiGap
	MBTS like detectors.
std::vector< double >	m_mbtsPositionZ
	MBTS like detectors.
std::vector< double >	m_mbtsStaggeringZ
	MBTS like detectors.
StringProperty	m_entryVolume {this, "EntryVolumeName", "Calo::Container::EntryVolume"}
	name of the Calo entrance
StringProperty	m_exitVolume {this, "ExitVolumeName", "Calo::Container"}
	name of the Calo container

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

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

Detailed Description

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

This is the underlying implementation logic that is shared by the the concrete builders

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

~CaloTrackingGeometryBuilderImpl()

Calo::CaloTrackingGeometryBuilderImpl::~CaloTrackingGeometryBuilderImpl ( )

virtualdefault

Destructor.

CaloTrackingGeometryBuilderImpl()

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

protected

Constructor.

Helper Tool to create TrackingVolume Arrays

Definition at line 36 of file CaloTrackingGeometryBuilderImpl.cxx.

    : AthAlgTool(t, n, p) {
}

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

protected

method to build enclosed beam pipe volumes

Definition at line 1493 of file CaloTrackingGeometryBuilderImpl.cxx.

                                                     {
  outerRadius = 0.;
 
  // 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;
 
    auto bpBounds =
        std::make_shared<Trk::CylinderVolumeBounds>(0., outerRadius, 0.5 * (zmax - zmin));
 
    auto bpPos = std::make_unique<Amg::Transform3D>(
        Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin + zmax))));
 
    Trk::TrackingVolume* bpVolPos =
        new Trk::TrackingVolume(std::move(bpPos),
                                std::make_shared<Trk::CylinderVolumeBounds>(*bpBounds),
                                m_caloMaterial, nullptr,
                                nullptr, "BeamPipe::Positive" + name);
 
    auto bpNeg = std::make_unique<Amg::Transform3D>(
        Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zmin + zmax))));
 
    Trk::TrackingVolume* bpVolNeg = new Trk::TrackingVolume(
        std::move(bpNeg),
        std::move(bpBounds),
        m_caloMaterial, nullptr, nullptr,
        "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
    auto bpBounds = std::make_shared<Trk::CylinderVolumeBounds>(
        0., dim[i].first, 0.5 * (dim[i + 1].second - dim[i].second));
 
    auto bpPos = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
        Amg::Vector3D(0., 0., 0.5 * (dim[i + 1].second + dim[i].second))));
 
    auto  bpPB = std::make_unique<Amg::Transform3D>(*bpPos);
 
    Trk::TrackingVolume* bpVolPos =
        new Trk::TrackingVolume(std::move(bpPos),std::move(bpBounds), m_caloMaterial, nullptr,
                                nullptr, "BeamPipe::Positive" + name);
    bpVolPos->sign(Trk::BeamPipe);
 
    Trk::TrackingVolume* bpVolGap = nullptr;
    if (dim[i].first < outerRadius) {
      auto bpGB = std::make_shared<Trk::CylinderVolumeBounds>(
          dim[i].first, outerRadius, 0.5 * (dim[i + 1].second - dim[i].second));
 
      bpVolGap = new Trk::TrackingVolume(std::move(bpPB), std::move(bpGB), m_caloMaterial,
                                         nullptr, nullptr,
                                         "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
    auto bpBounds = std::make_shared<Trk::CylinderVolumeBounds>(0., dim[i].first, 0.5 * (zmax2 - zmin2));
 
    auto bpNeg = std::make_unique<Amg::Transform3D>(
        Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin2 + zmax2))));
 
    Trk::TrackingVolume* bpVolNeg =
        new Trk::TrackingVolume(std::make_unique<Amg::Transform3D>(*bpNeg),
                                std::move(bpBounds), m_caloMaterial, nullptr,
                                nullptr, "BeamPipe::Negative" + name);
    bpVolNeg->sign(Trk::BeamPipe);
 
    Trk::TrackingVolume* bpVolGap =
        dim[i].first < outerRadius
            ? new Trk::TrackingVolume(
                  std::move(bpNeg),
                  std::make_shared<Trk::CylinderVolumeBounds>(dim[i].first, outerRadius,
                                                              0.5 * (zmax2 - zmin2)),
                  m_caloMaterial, nullptr, nullptr,
                  "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

TrackingGeometry Interface method.

Definition at line 75 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.;
 
  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) {
    auto idBounds = std::make_shared<Trk::CylinderVolumeBounds>(
        enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
 
    auto idTr = std::make_unique<Amg::Transform3D>(Trk::s_idTransform);
 
    innerVol =
        new Trk::TrackingVolume(std::move(idTr), std::move(idBounds), m_caloMaterial, nullptr,
                                nullptr, "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 "
        "---------------------------------------------------------- ");
    auto tileVolIter = tileVolumes.begin();
    auto 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();
      auto dibo = std::make_shared<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, std::make_shared<Trk::DiscBounds>(*dibo),
          // mbtsPosLayerSurfArray,
          Trk::HomogeneousLayerMaterial(
              Trk::MaterialProperties(m_caloMaterial, 1.), 1.),
          1. * Gaudi::Units::mm);
 
      mbtsNegLayers->push_back(mbtsNegLayer);
      mbtsPosLayers->push_back(mbtsPosLayer);
    }
  }
 
  // building inner gap
  auto lArG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
      rInnerGapBP,
      // lArPositiveEndcapBounds->outerRadius(),
      keyDim[0].first, 0.5 * (keyDim.back().second - keyDim[0].second));
 
  auto lArG1P =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
  lArPositiveSectorInnerGap = new Trk::TrackingVolume(
      std::move(lArG1P),  std::make_shared<Trk::CylinderVolumeBounds>(*lArG1Bounds),
      lArSectorInnerGapMaterial, std::move(mbtsPosLayers),
      "Calo::GapVolumes::LAr::PositiveSectorInnerGap");
 
  auto lArG1N =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
  lArNegativeSectorInnerGap = new Trk::TrackingVolume(
      std::move(lArG1N),
      std::move(lArG1Bounds),
      lArSectorInnerGapMaterial,
      std::move(mbtsNegLayers), "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();
 
  auto ecpPos = std::make_unique<Amg::Transform3D>(lArPosECPresampler->transform());
  auto ecpNeg = std::make_unique<Amg::Transform3D>(lArNegECPresampler->transform());
 
  auto ecpUpBounds = std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
  auto ecpDownBounds = std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
 
  Trk::TrackingVolume* ecPresamplerCoverPos = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpUpBounds),
      m_Al, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveECPresamplerCover");
  Trk::TrackingVolume* ecPresamplerCoverNeg = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*ecpNeg),
      std::move(ecpUpBounds), m_Al, nullptr, nullptr,
      "Calo::GapVolumes::LAr::NegativeECPresamplerCover");
  Trk::TrackingVolume* ecPresamplerInnerPos = new Trk::TrackingVolume(
      std::move(ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpDownBounds),
      m_Al, nullptr,
      nullptr, "Calo::GapVolumes::LAr::PositiveECPresamplerInner");
  Trk::TrackingVolume* ecPresamplerInnerNeg = new Trk::TrackingVolume(
      std::move(ecpNeg),
      std::move(ecpDownBounds),
      m_Al, nullptr,
      nullptr, "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();
 
  auto ecIPos = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
      Amg::Vector3D(0., 0., 0.5 * (z + keyDim.back().second))));
 
  auto ecINeg = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
      Amg::Vector3D(0., 0., -0.5 * (z + keyDim.back().second))));
 
  auto ecpIBounds = std::make_shared<Trk::CylinderVolumeBounds>(
      rEndcapBP, keyDim.back().first, 0.5 * (z - keyDim.back().second));
 
  auto ecOPos = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (z1 + z2))));
 
  auto ecONeg = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (z1 + z2))));
 
  auto ecpOBounds = std::make_shared<Trk::CylinderVolumeBounds>(
      rEndcapBP, keyDim.back().first, 0.5 * (z2 - z1));
 
  Trk::TrackingVolume* ecPresamplerInPos = new Trk::TrackingVolume(
      std::move(ecIPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpIBounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveECPresamplerIn");
  Trk::TrackingVolume* ecPresamplerInNeg = new Trk::TrackingVolume(
      std::move(ecINeg), std::move(ecpIBounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::NegativeECPresamplerIn");
  Trk::TrackingVolume* ecPresamplerOutPos = new Trk::TrackingVolume(
      std::move(ecOPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpOBounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveECPresamplerOut");
  Trk::TrackingVolume* ecPresamplerOutNeg = new Trk::TrackingVolume(
      std::move(ecONeg), std::move(ecpOBounds),
      m_Ar, nullptr, nullptr,
      "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();
 
  auto ecPos =
      std::make_unique<Amg::Transform3D>(lArPositiveEndcap->transform());
  auto ecNeg =
      std::make_unique<Amg::Transform3D>(lArNegativeEndcap->transform());
 
  auto ecUpBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
  auto ecDownBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
 
  Trk::TrackingVolume* ecCoverPos = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*ecPos),
      std::make_shared<Trk::CylinderVolumeBounds>(*ecUpBounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveEndcapCover");
  Trk::TrackingVolume* ecCoverNeg = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*ecNeg),
      std::move(ecUpBounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::NegativeEndcapCover");
  Trk::TrackingVolume* ecInnerPos = new Trk::TrackingVolume(
      std::move(ecPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecDownBounds),
      m_Al, nullptr,
      nullptr, "Calo::GapVolumes::LAr::PositiveEndcapInner");
  Trk::TrackingVolume* ecInnerNeg = new Trk::TrackingVolume(
      std::move(ecNeg),
      std::move(ecDownBounds),
      m_Al, nullptr,
      nullptr, "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
  auto lArHecInnerGapBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(rHecBP, lArPositiveHecBounds->innerRadius(),
                                    lArPositiveHecBounds->halflengthZ());
 
  auto lArHecPos = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveHec->center().z())));
  auto lArHecNeg = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeHec->center().z())));
 
  Trk::TrackingVolume* lArPositiveHecInnerGap = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*lArHecPos),
      lArHecInnerGapBounds, m_Al, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveHecInnerGap");
 
  Trk::TrackingVolume* lArNegativeHecInnerGap = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*lArHecNeg),
      std::make_shared<Trk::CylinderVolumeBounds>(*lArHecInnerGapBounds),
      m_Al, nullptr, nullptr,
      "Calo::GapVolumes::LAr::NegativeHecInnerGap");
  // create the Bounds
  auto lArHecOuterGapBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->outerRadius(),
                                                  keyDim.back().first,
                                                  lArPositiveHecBounds->halflengthZ());
 
  Trk::TrackingVolume* lArPositiveHecOuterGap = new Trk::TrackingVolume(
      std::move(lArHecPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArHecOuterGapBounds),
      m_Ar, nullptr,
      nullptr, "Calo::GapVolumes::LAr::PositiveHecOuterGap");
 
  Trk::TrackingVolume* lArNegativeHecOuterGap = new Trk::TrackingVolume(
      std::move(lArHecNeg),
      std::move(lArHecOuterGapBounds), m_Ar,
      nullptr, nullptr, "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
  auto lArFcalInnerGapBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(rFcalBP,
                                    lArPositiveFcalBounds->innerRadius(),
                                    lArPositiveFcalBounds->halflengthZ());
 
  auto lArFcalPos = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveFcal->center().z())));
  auto lArFcalNeg = std::make_unique<Amg::Transform3D>(
      Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeFcal->center().z())));
 
  Trk::TrackingVolume* lArPositiveFcalInnerGap = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*lArFcalPos),
      std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalInnerGapBounds),
      m_Al, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveFcalInnerGap");
 
  Trk::TrackingVolume* lArNegativeFcalInnerGap = new Trk::TrackingVolume(
      std::make_unique<Amg::Transform3D>(*lArFcalNeg),
      std::move(lArFcalInnerGapBounds), m_Al, nullptr,
      nullptr, "Calo::GapVolumes::LAr::NegativeFcalInnerGap");
 
  // create the Bounds
  auto lArFcalOuterGapBounds =
      std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->outerRadius(),
                                    keyDim.back().first,
                                    lArPositiveFcalBounds->halflengthZ());
 
  Trk::TrackingVolume* lArPositiveFcalOuterGap = new Trk::TrackingVolume(
      std::move(lArFcalPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalOuterGapBounds),
      m_Ar, nullptr, nullptr, "Calo::GapVolumes::LAr::PositiveFcalOuterGap");
 
  Trk::TrackingVolume* lArNegativeFcalOuterGap = new Trk::TrackingVolume(
      std::move(lArFcalNeg), std::move(lArFcalOuterGapBounds), m_Ar,
      nullptr, nullptr, "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);
 
  auto lArSectorOuterG0Bounds =
      std::make_shared<Trk::CylinderVolumeBounds>(
          rOutBP, 430.,
          // lArPositiveEndcapBounds->outerRadius(),
          0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
 
  auto lArSectorOuterG1Bounds =
      std::make_shared<Trk::CylinderVolumeBounds>(
          430., keyDim.back().first,
          // lArPositiveEndcapBounds->outerRadius(),
          0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
 
  z = 0.5 * (caloPositiveOuterBoundary + lArPositiveOuterBoundary);
 
  auto lArSecOutG1P =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
  auto lArSecOutG0P =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  lArPositiveSectorOuterGap0 = new Trk::TrackingVolume(
      std::move(lArSecOutG0P), std::make_shared<Trk::CylinderVolumeBounds>(*lArSectorOuterG0Bounds),
      lArSectorOuterGapMat, nullptr,
      nullptr, "Calo::GapVolumes::LAr::PositiveSectorOuterGap0");
 
  lArPositiveSectorOuterGap = new Trk::TrackingVolume(
      std::move(lArSecOutG1P), std::make_shared<Trk::CylinderVolumeBounds> (*lArSectorOuterG1Bounds),
      m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LAr::PositiveSectorOuterGap");
 
  auto lArSecOutG1N =
       std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
  auto lArSecOutG0N =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  lArNegativeSectorOuterGap0 =
      new Trk::TrackingVolume(std::move(lArSecOutG0N),
                              std::move(lArSectorOuterG0Bounds),
                              lArSectorOuterGapMat, nullptr, nullptr,
                              "Calo::GapVolumes::LAr::NegativeSectorOuterGap0");
 
  lArNegativeSectorOuterGap = new Trk::TrackingVolume(
      std::move(lArSecOutG1N),
      std::move(lArSectorOuterG1Bounds),
      m_Ar, nullptr,
      nullptr, "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
  auto trtSolGapBounds = std::make_shared<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, std::move(trtSolGapBounds), solGapMat, nullptr,
                              nullptr, "Calo::GapVolumes::SolenoidGap");
 
  auto lArTileCentralG1Bounds =
      std::make_shared<Trk::CylinderVolumeBounds>(lArBarrelBounds->outerRadius(),
                                    tileCombinedBounds->innerRadius(),
                                    lArBarrelBounds->halflengthZ());
 
  lArTileCentralSectorGap = new Trk::TrackingVolume(
      nullptr, std::move(lArTileCentralG1Bounds), m_Ar, nullptr, nullptr,
      "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(std::make_shared<Trk::Material>(m_Scint), baseID);
  matCrack.emplace_back(std::make_shared<Trk::Material>(m_caloMaterial), -1);
  matCrack.emplace_back(std::make_shared<Trk::Material>(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;
  auto bun = Trk::BinUtility(nbins, -1.8, -1.2, Trk::open, Trk::binEta);
  auto bup = 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 = Trk::BinUtility(steps, Trk::open, Trk::binZ);
    layUP[i] = zBU;
    indexP.push_back(indx);
  }
 
  const Trk::BinnedMaterial crackBinPos(m_crackMaterial, bup, layUP, indexP,
                                        matCrack);
 
  auto crackBoundsPos = std::make_shared<Trk::CylinderVolumeBounds>(
      keyDim[0].first, tileCombinedBounds->innerRadius(),
      0.5 * (keyDim.back().second - crackZ1));
  z = 0.5 * (keyDim.back().second + crackZ1);
  auto crackPosTransform =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  Trk::AlignableTrackingVolume* crackPos = new Trk::AlignableTrackingVolume(
      std::move(crackPosTransform), 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 = Trk::BinUtility(steps, Trk::open, Trk::binZ);
    layDN[i] = zBU;
    indexN.push_back(indx);
  }
 
  const Trk::BinnedMaterial crackBinNeg(m_crackMaterial, bun, layDN, indexN, matCrack);
 
  auto crackNegTransform =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  Trk::AlignableTrackingVolume* crackNeg = new Trk::AlignableTrackingVolume(
      std::move(crackNegTransform),
      std::make_shared<Trk::CylinderVolumeBounds>(*crackBoundsPos), crackBinNeg, 17,
      "Calo::Detectors::Tile::CrackNeg");
 
  auto lArCentralG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
      keyDim[0].first, tileCombinedBounds->innerRadius(),
      0.5 * (crackZ1 - lArBarrelBounds->halflengthZ()));
 
  z = 0.5 * (crackZ1 + lArBarrelBounds->halflengthZ());
  auto lArCentralG1P =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
 
  lArCentralPositiveGap = new Trk::TrackingVolume(
      std::move(lArCentralG1P),
      std::make_shared<Trk::CylinderVolumeBounds>(*lArCentralG1Bounds), m_Ar, nullptr, nullptr,
      "Calo::GapVolumes::LArCentralPositiveGap");
 
  auto lArCentralG1N =
      std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
 
  lArCentralNegativeGap = new Trk::TrackingVolume(
      std::move(lArCentralG1N),
      std::move(lArCentralG1Bounds),
      m_Ar, nullptr,
      nullptr, "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);
 
    auto centralSynBounds = std::make_shared<Trk::CylinderVolumeBounds>(
        caloVolsOuterRadius, caloDefaultRadius, caloVolsExtendZ);
    centralBuffer = new Trk::TrackingVolume(
        nullptr, std::move(centralSynBounds), m_caloMaterial, nullptr, nullptr,
        "Calo::GapVolumes::EnvelopeBuffer");
  }
 
  if (caloVolsExtendZ < caloDefaultHalflengthZ) {
    ATH_MSG_VERBOSE(
        "Build longitudinal buffers to synchronize the boundaries in between Z "
        << caloVolsExtendZ << " and " << caloDefaultHalflengthZ);
 
    auto endcapSynBounds = std::make_shared<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(
        std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., zPos))),
        std::make_shared<Trk::CylinderVolumeBounds>(*endcapSynBounds),
        m_Ar, nullptr, nullptr,
        "Calo::GapVolumes::PosECBuffer");
 
    ecNegBuffer = new Trk::TrackingVolume(
        std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -zPos))),
        std::move(endcapSynBounds), m_Ar, nullptr, nullptr,
        "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;
 
      auto cutInBounds =
          std::make_shared<Trk::CylinderVolumeBounds>(rCutOutBP, rcut, 0.5 * (zup - zlow));
      Trk::TrackingVolume* caloInPos = new Trk::TrackingVolume(
        std::make_unique<Amg::Transform3D>(
          Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
          std::make_shared<Trk::CylinderVolumeBounds>(*cutInBounds),
          cutOutMat[mindex], nullptr, nullptr,
          "Calo::GapVolumes::CaloPositiveCutIn" + ss.str());
      Trk::TrackingVolume* caloInNeg = new Trk::TrackingVolume(
          std::make_unique<Amg::Transform3D>(
            Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
          std::move(cutInBounds),
          cutOutMat[mindex], nullptr, nullptr,
          "Calo::GapVolumes::CaloNegativeCutIn" + ss.str());
      // build cutout ( -> MS ) : geometry signature needs to be resolved later
      // : follow naming convention
      auto cutOutBounds = std::make_shared<Trk::CylinderVolumeBounds>(rcut, rout, 0.5 * (zup - zlow));
      Trk::TrackingVolume* caloOutPos = new Trk::TrackingVolume(
          std::make_unique<Amg::Transform3D>(
              Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
          std::make_shared<Trk::CylinderVolumeBounds>(*cutOutBounds), m_caloMaterial, nullptr, nullptr,
          "Muon::GapVolumes::CaloPositiveCutOut" + ss.str());
      Trk::TrackingVolume* caloOutNeg = new Trk::TrackingVolume(
          std::make_unique<Amg::Transform3D>(
              Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
          std::move(cutOutBounds),
          m_caloMaterial, nullptr, nullptr,
          "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.");
 
  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()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

initialize()

StatusCode Calo::CaloTrackingGeometryBuilderImpl::initialize ( )

overridevirtual

AlgTool initailize method.

Reimplemented in Calo::CaloTrackingGeometryBuilder, and Calo::CaloTrackingGeometryBuilderCond.

Definition at line 46 of file CaloTrackingGeometryBuilderImpl.cxx.

                                                           {
 
  // Retrieve the tracking volume array creator
  // -------------------------------------------------
  ATH_CHECK(m_trackingVolumeArrayCreator.retrieve());
  ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeArrayCreator);
  
  // Retrieve the second volume creator
  if (m_buildMBTS) {
    ATH_CHECK(m_trackingVolumeCreator.retrieve());
    ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeCreator);
  };
 
  // Retrieve the volume builders
  // -------------------------------------------------
  ATH_CHECK(m_lArVolumeBuilder.retrieve());
  ATH_MSG_INFO("Retrieved tool " << m_lArVolumeBuilder);
 
  // Retrieve the tracking volume helper
  // -------------------------------------------------
  ATH_CHECK(m_tileVolumeBuilder.retrieve());
  ATH_MSG_INFO("Retrieved tool " << m_tileVolumeBuilder);
 
  ATH_MSG_INFO("initialize() succesful");
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

registerInLayerIndexCaloSampleMap()

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

protected

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

Definition at line 1434 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;
 
  std::span<Trk::Layer const* const> layerObjects =
      confinedLayers->arrayObjects();
  std::span<Trk::Layer const* const>::iterator layerObjIter =
      layerObjects.begin();
  std::span<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

inline

The unique signature.

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

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_Al

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

protected

Definition at line 86 of file CaloTrackingGeometryBuilderImpl.h.

{88.93, 388.62, 26.98, 13., 0.0027};

m_Ar

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

protected

Definition at line 85 of file CaloTrackingGeometryBuilderImpl.h.

{140.036, 856.32, 39.948, 18., 0.0014};

m_buildMBTS

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

protected

MBTS like detectors.

Definition at line 103 of file CaloTrackingGeometryBuilderImpl.h.

{this, "BuildMBTS", true};  

m_caloDefaultHalflengthZ

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

protected

the halflength in z if not built from

GeoModel

Definition at line 95 of file CaloTrackingGeometryBuilderImpl.h.

{this, "CalorimeterHalflengthZ", 6500.};  

m_caloDefaultRadius

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

protected

the radius if not built from GeoModel

Definition at line 94 of file CaloTrackingGeometryBuilderImpl.h.

{this, "CalorimeterRadius", 4250.};       

m_caloEnvelope

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

protected

Envelope cover for Gap Layers.

Definition at line 90 of file CaloTrackingGeometryBuilderImpl.h.

{this, "GapLayerEnvelope", 25 * Gaudi::Units::mm};  

m_caloMaterial

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

protected

Definition at line 84 of file CaloTrackingGeometryBuilderImpl.h.

{};

m_crackMaterial

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

protected

Definition at line 88 of file CaloTrackingGeometryBuilderImpl.h.

{424.35, 707.43, 11.16, 5.61, 0.001}; // Scintillator/Glue (G4 def.)

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

protected

Definition at line 92 of file CaloTrackingGeometryBuilderImpl.h.

{this, "EnvelopeDefinitionSvc", "AtlasGeometry_EnvelopeDefSvc"};

m_entryVolume

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

protected

name of the Calo entrance

Definition at line 111 of file CaloTrackingGeometryBuilderImpl.h.

{this, "EntryVolumeName", "Calo::Container::EntryVolume"};  

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

protected

name of the Calo container

Definition at line 112 of file CaloTrackingGeometryBuilderImpl.h.

{this, "ExitVolumeName", "Calo::Container"};   

m_indexStaticLayers

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

protected

forces robust indexing for layers

Definition at line 98 of file CaloTrackingGeometryBuilderImpl.h.

{this, "IndexStaticLayers", true};  

m_lArVolumeBuilder

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

protected

Volume Builder for the Tile Calorimeter.

Definition at line 79 of file CaloTrackingGeometryBuilderImpl.h.

{this, "LArVolumeBuilder", "LAr::LArVolumeBuilder/LArVolumeBuilder"};

m_layerIndexCaloSampleMapName

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

protected

name to record it

Definition at line 101 of file CaloTrackingGeometryBuilderImpl.h.

{this, "LayerIndexCaloSampleMapName", "LayerIndexCaloSampleMap"};  

m_mbtsPhiGap

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

protected

MBTS like detectors.

Definition at line 107 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsPhiSegments

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

protected

MBTS like detectors.

Definition at line 106 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsPositionZ

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

protected

MBTS like detectors.

Definition at line 108 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsRadiusGap

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

protected

MBTS like detectors.

Definition at line 105 of file CaloTrackingGeometryBuilderImpl.h.

m_mbtsStaggeringZ

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

protected

MBTS like detectors.

Definition at line 109 of file CaloTrackingGeometryBuilderImpl.h.

m_recordLayerIndexCaloSampleMap

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

protected

for deposition methods

Definition at line 100 of file CaloTrackingGeometryBuilderImpl.h.

{this, "RecordLayerIndexCaloSampleMap", true};       

m_Scint

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

protected

Definition at line 87 of file CaloTrackingGeometryBuilderImpl.h.

{424.35, 707.43, 11.16, 5.61, 0.001};  // from G4 definition

m_tileVolumeBuilder

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

protected

Material properties.

Definition at line 81 of file CaloTrackingGeometryBuilderImpl.h.

{this, "TileVolumeBuilder", "Tile::TileVolumeBuilder/TileVolumeBuilder"};

m_trackingVolumeArrayCreator

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

protected

Second helper for volume creation.

Definition at line 75 of file CaloTrackingGeometryBuilderImpl.h.

{this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"};

m_trackingVolumeCreator

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

protected

Volume Builder for the Liquid Argon Calorimeter.

Definition at line 77 of file CaloTrackingGeometryBuilderImpl.h.

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

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:

• CaloTrackingGeometryBuilderImpl.h
• CaloTrackingGeometryBuilderImpl.cxx