ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
Calo::CaloTrackingGeometryBuilder Class Referencefinal

#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, V, H > &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"}
 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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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.

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

◆ ~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 1493 of file CaloTrackingGeometryBuilderImpl.cxx.

1495  {
1496  outerRadius = 0.;
1497 
1498  // beam pipe thickness along the z distance
1499  if (bpCutouts.empty()) {
1500  return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(0, 0);
1501  }
1502 
1503  RZPairVector dim;
1504  dim.emplace_back(bpCutouts[0].first, zmin);
1505  float rOut = bpCutouts[0].first;
1506  for (const auto& bpCutout : bpCutouts) {
1507  if (bpCutout.second <= dim[0].second)
1508  dim[0].first = bpCutout.first;
1509  else if (bpCutout.second <= zmax)
1510  dim.push_back(bpCutout);
1511  if (bpCutout.second <= zmax)
1512  rOut = bpCutout.first;
1513  }
1514 
1515  if (dim.back().second < zmax)
1516  dim.emplace_back(rOut, zmax);
1517 
1518  if (dim.size() == 2) { // simple case
1519 
1520  outerRadius = dim[0].first;
1521 
1522  auto bpBounds =
1523  std::make_shared<Trk::CylinderVolumeBounds>(0., outerRadius, 0.5 * (zmax - zmin));
1524 
1525  auto bpPos = std::make_unique<Amg::Transform3D>(
1526  Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin + zmax))));
1527 
1528  Trk::TrackingVolume* bpVolPos =
1529  new Trk::TrackingVolume(std::move(bpPos),
1530  std::make_shared<Trk::CylinderVolumeBounds>(*bpBounds),
1531  m_caloMaterial, nullptr,
1532  nullptr, "BeamPipe::Positive" + name);
1533 
1534  auto bpNeg = std::make_unique<Amg::Transform3D>(
1535  Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zmin + zmax))));
1536 
1537  Trk::TrackingVolume* bpVolNeg = new Trk::TrackingVolume(
1538  std::move(bpNeg),
1539  std::move(bpBounds),
1540  m_caloMaterial, nullptr, nullptr,
1541  "BeamPipe::Negative" + name);
1542 
1543  // geometry signature
1544  bpVolPos->sign(Trk::BeamPipe);
1545  bpVolNeg->sign(Trk::BeamPipe);
1546 
1547  return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(bpVolPos,
1548  bpVolNeg);
1549  }
1550 
1551  // cutout included
1552 
1553  outerRadius = dim[0].first;
1554 
1555  // find rMax
1556  for (unsigned int i = 1; i < dim.size(); i++)
1557  if (dim[i].first > outerRadius)
1558  outerRadius = dim[i].first;
1559 
1560  // loop over z sections, prepare volumes for gluing
1561  std::vector<Trk::TrackingVolume*> posVols;
1562 
1563  for (unsigned int i = 0; i < dim.size() - 1; i++) {
1564 
1565  if (dim[i].second == dim[i + 1].second)
1566  continue;
1567 
1568  // beam pipe volume
1569  auto bpBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1570  0., dim[i].first, 0.5 * (dim[i + 1].second - dim[i].second));
1571 
1572  auto bpPos = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
1573  Amg::Vector3D(0., 0., 0.5 * (dim[i + 1].second + dim[i].second))));
1574 
1575  auto bpPB = std::make_unique<Amg::Transform3D>(*bpPos);
1576 
1577  Trk::TrackingVolume* bpVolPos =
1578  new Trk::TrackingVolume(std::move(bpPos),std::move(bpBounds), m_caloMaterial, nullptr,
1579  nullptr, "BeamPipe::Positive" + name);
1580  bpVolPos->sign(Trk::BeamPipe);
1581 
1582  Trk::TrackingVolume* bpVolGap = nullptr;
1583  if (dim[i].first < outerRadius) {
1584  auto bpGB = std::make_shared<Trk::CylinderVolumeBounds>(
1585  dim[i].first, outerRadius, 0.5 * (dim[i + 1].second - dim[i].second));
1586 
1587  bpVolGap = new Trk::TrackingVolume(std::move(bpPB), std::move(bpGB), m_caloMaterial,
1588  nullptr, nullptr,
1589  "Calo::GapVolumes::Positive" + name);
1590  }
1591 
1592  Trk::TrackingVolume* bpSector = bpVolPos;
1593 
1594  if (bpVolGap) {
1595  std::vector<Trk::TrackingVolume*> gapVols;
1596  gapVols.push_back(bpVolPos);
1597  gapVols.push_back(bpVolGap);
1598  bpSector = m_trackingVolumeCreator->createContainerTrackingVolume(
1599  gapVols, m_caloMaterial, "Calo::Container::PositiveBPSector" + name);
1600  }
1601  posVols.push_back(bpSector);
1602  }
1603 
1604  Trk::TrackingVolume* bpPosSector =
1605  m_trackingVolumeCreator->createContainerTrackingVolume(
1606  posVols, m_caloMaterial, "Calo::Container::PositiveBP" + name);
1607 
1608  // loop over z sections, prepare volumes for gluing
1609  std::vector<Trk::TrackingVolume*> negVols;
1610 
1611  for (unsigned int i = 0; i < dim.size() - 1; i++) {
1612 
1613  float zmax2 = -1. * (dim[i].second);
1614  float zmin2 = -1. * (dim[i + 1].second);
1615 
1616  if (zmin2 == zmax2)
1617  continue;
1618 
1619  // beam pipe volume
1620  auto bpBounds = std::make_shared<Trk::CylinderVolumeBounds>(0., dim[i].first, 0.5 * (zmax2 - zmin2));
1621 
1622  auto bpNeg = std::make_unique<Amg::Transform3D>(
1623  Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zmin2 + zmax2))));
1624 
1625  Trk::TrackingVolume* bpVolNeg =
1626  new Trk::TrackingVolume(std::make_unique<Amg::Transform3D>(*bpNeg),
1627  std::move(bpBounds), m_caloMaterial, nullptr,
1628  nullptr, "BeamPipe::Negative" + name);
1629  bpVolNeg->sign(Trk::BeamPipe);
1630 
1631  Trk::TrackingVolume* bpVolGap =
1632  dim[i].first < outerRadius
1633  ? new Trk::TrackingVolume(
1634  std::move(bpNeg),
1635  std::make_shared<Trk::CylinderVolumeBounds>(dim[i].first, outerRadius,
1636  0.5 * (zmax2 - zmin2)),
1637  m_caloMaterial, nullptr, nullptr,
1638  "Calo::GapVolumes::Negative" + name)
1639  : nullptr;
1640 
1641  Trk::TrackingVolume* bpSector = bpVolNeg;
1642 
1643  if (bpVolGap) {
1644  std::vector<Trk::TrackingVolume*> gapVols;
1645  gapVols.push_back(bpVolNeg);
1646  gapVols.push_back(bpVolGap);
1647  bpSector = m_trackingVolumeCreator->createContainerTrackingVolume(
1648  gapVols, m_caloMaterial, "Calo::Container::NegativeBPSector" + name);
1649  }
1650 
1651  if (negVols.empty())
1652  negVols.push_back(bpSector);
1653  else
1654  negVols.insert(negVols.begin(), bpSector);
1655  }
1656 
1657  Trk::TrackingVolume* bpNegSector =
1658  m_trackingVolumeCreator->createContainerTrackingVolume(
1659  negVols, m_caloMaterial, "Calo::Container::NegativeBP" + name);
1660 
1661  return std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*>(bpPosSector,
1662  bpNegSector);
1663 }

◆ 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 75 of file CaloTrackingGeometryBuilderImpl.cxx.

77  {
78 
79  ATH_MSG_VERBOSE("Starting to build CaloTrackingGeometry ...");
80 
81  Trk::TrackingVolume* calorimeter = nullptr;
82 
83  // the key dimensions
84  RZPairVector keyDim;
85 
86  // the enclosed input volume (ID)
87  double enclosedInnerSectorHalflength = 0.;
88  double enclosedInnerSectorRadius = 0.;
89 
90  if (innerVol) {
91  ATH_MSG_VERBOSE("Got Inner Detector Volume: " << innerVol->volumeName());
92  innerVol->screenDump(msg(MSG::VERBOSE));
93 
94  // retrieve dimensions
95  const Trk::CylinderVolumeBounds* innerDetectorBounds =
96  dynamic_cast<const Trk::CylinderVolumeBounds*>(
97  &(innerVol->volumeBounds()));
98  if (!innerDetectorBounds)
99  std::abort();
100 
101  enclosedInnerSectorHalflength = innerDetectorBounds->halflengthZ();
102  enclosedInnerSectorRadius = innerDetectorBounds->outerRadius();
103 
104  keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
105  }
106  // get the dimensions from the envelope service
107  const RZPairVector& envelopeDefsIn =
108  m_enclosingEnvelopeSvc->getCaloRZBoundary();
109 
110  // find the max,max pair
111  unsigned int ii = 0;
112  for (unsigned int i = 0; i < envelopeDefsIn.size(); i++) {
113  if (envelopeDefsIn[i].second > envelopeDefsIn[ii].second)
114  ii = i;
115  else if (envelopeDefsIn[i].second == envelopeDefsIn[ii].second &&
116  envelopeDefsIn[i].first > envelopeDefsIn[ii].first)
117  ii = i;
118  }
119 
120  // find the sense of rotation
121  int irot = 1;
122  unsigned int inext = ii + 1;
123  if (inext == envelopeDefsIn.size())
124  inext = 0;
125  if (envelopeDefsIn[inext].second != envelopeDefsIn[ii].second) {
126  irot = -1;
127  inext = ii > 0 ? ii - 1 : envelopeDefsIn.size() - 1;
128  }
129 
130  // fill starting with upper low edge, end with upper high edge
131  RZPairVector envelopeDefs;
132  if (irot > 0) {
133  for (unsigned int i = inext; i < envelopeDefsIn.size(); i++)
134  envelopeDefs.push_back(envelopeDefsIn[i]);
135  if (inext > 0)
136  for (unsigned int i = 0; i <= inext - 1; i++)
137  envelopeDefs.push_back(envelopeDefsIn[i]);
138  } else {
139  int i = inext;
140  while (i >= 0) {
141  envelopeDefs.push_back(envelopeDefsIn[i]);
142  i = i - 1;
143  };
144  inext = envelopeDefsIn.size() - 1;
145  while (inext >= ii) {
146  envelopeDefs.push_back(envelopeDefsIn[inext]);
147  inext = inext - 1;
148  };
149  }
150 
151  double envEnclosingVolumeHalfZ = m_caloDefaultHalflengthZ;
152 
153  ATH_MSG_VERBOSE("Calo envelope definition retrieved:");
154  RZPairVector msCutouts;
155  for (unsigned int i = 0; i < envelopeDefs.size(); i++) {
156  ATH_MSG_VERBOSE("Rz pair:" << i << ":" << envelopeDefs[i].first << ","
157  << envelopeDefs[i].second);
158  if (std::abs(envelopeDefs[i].second) < envEnclosingVolumeHalfZ)
159  envEnclosingVolumeHalfZ = std::abs(envelopeDefs[i].second);
160  // ID dimensions : pick 1100 < R < 1200
161  if (envelopeDefs[i].first > 1100. && envelopeDefs[i].first < 1200. &&
162  envelopeDefs[i].second > 0.) {
163  // check that radial size of ID envelope fits
164  if (enclosedInnerSectorRadius != envelopeDefs[i].first)
165  ATH_MSG_INFO(
166  "Enclosed ID volume radius does not match ID envelope, adjusting "
167  "Calo.");
168  envEnclosingVolumeHalfZ = envelopeDefs[i].second;
169  if (!innerVol) {
170  enclosedInnerSectorRadius = envelopeDefs[i].first;
171  enclosedInnerSectorHalflength = envelopeDefs[i].second;
172  }
173  }
174  // collect outer cutouts, process those with |z| < 6785.mm ( this cut should
175  // be synchronized with MS default size,
176  // MS builder would crash for a longer input volume )
177  if (envelopeDefs[i].second > 0. && envelopeDefs[i].second < 6785. &&
178  (envelopeDefs[i].first > 1200. ||
179  envelopeDefs[i].second > envEnclosingVolumeHalfZ)) {
180  if (msCutouts.empty())
181  msCutouts.push_back(envelopeDefs[i]);
182  else {
183  RZPairVector::iterator envIter = msCutouts.begin();
184  while (envIter != msCutouts.end() &&
185  (*envIter).second < envelopeDefs[i].second)
186  ++envIter;
187  while (envIter != msCutouts.end() &&
188  (*envIter).second == envelopeDefs[i].second &&
189  (*envIter).first > envelopeDefs[i].first)
190  ++envIter;
191  msCutouts.insert(envIter, envelopeDefs[i]);
192  }
193  }
194  // end outer (MS) cutouts
195  }
196  if (msgLvl(MSG::VERBOSE)) {
197  for (unsigned int i = 0; i < msCutouts.size(); i++)
198  ATH_MSG_VERBOSE("MS cutouts to be processed by Calo:"
199  << i << ":" << msCutouts[i].first << ","
200  << msCutouts[i].second);
201  }
202 
203  // first member of msCutouts redefines the default central cylinder dimension
204  double caloDefaultRadius = m_caloDefaultRadius;
205  double caloDefaultHalflengthZ = m_caloDefaultHalflengthZ;
206 
207  if (!msCutouts.empty()) {
208  caloDefaultRadius = msCutouts[0].first;
209  caloDefaultHalflengthZ = msCutouts[0].second;
210  ATH_MSG_VERBOSE(
211  " Calo central cylinder dimensions adjusted using EnvelopeSvc:"
212  << m_caloDefaultRadius << "," << m_caloDefaultHalflengthZ);
213  }
214 
215  // create dummy ID if not built already
216 
217  if (!innerVol) {
218  auto idBounds = std::make_shared<Trk::CylinderVolumeBounds>(
219  enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
220 
221  auto idTr = std::make_unique<Amg::Transform3D>(Trk::s_idTransform);
222 
223  innerVol =
224  new Trk::TrackingVolume(std::move(idTr), std::move(idBounds), m_caloMaterial, nullptr,
225  nullptr, "Calo::GapVolumes::DummyID");
226 
227  keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
228  }
229 
230  // BEAM PIPE
231  const RZPairVector& bpDefs = m_enclosingEnvelopeSvc->getBeamPipeRZBoundary();
232 
233  ATH_MSG_VERBOSE("BeamPipe envelope definition retrieved:");
234  RZPairVector bpCutouts;
235  for (unsigned int i = 0; i < bpDefs.size(); i++) {
236  ATH_MSG_VERBOSE("Rz pair:" << i << ":" << bpDefs[i].first << ","
237  << bpDefs[i].second);
238  // beam pipe within calo : pick 10. < R < 200; envEnclosingVolumeHalfZ =<
239  // z <= msCutouts.back().second;
240  if (bpDefs[i].first > 10. && bpDefs[i].first < 200. &&
241  bpDefs[i].second >= envEnclosingVolumeHalfZ &&
242  bpDefs[i].second <= msCutouts.back().second) {
243  bpCutouts.push_back(bpDefs[i]);
244  }
245  if (i > 0 && i < 4)
246  keyDim.push_back(bpDefs[i]);
247  }
248 
249  // no beam pipe within ID
250  // if (bpCutouts[0].second == envEnclosingVolumeHalfZ && bpCutouts[0].first >
251  // 0 ) bpCutouts[0].first=0.;
252  // last not needed
253  if (bpCutouts.size() > 1 &&
254  bpCutouts.back().second == bpCutouts[bpCutouts.size() - 2].second)
255  bpCutouts.erase(bpCutouts.end() - 1);
256  // end beam pipe envelope within Calo
257  for (unsigned int i = 0; i < bpCutouts.size(); i++)
258  ATH_MSG_VERBOSE("Beam pipe dimensions to be used by Calo:"
259  << i << ":" << bpCutouts[i].first << ","
260  << bpCutouts[i].second);
261 
262  keyDim.emplace_back(caloDefaultRadius, caloDefaultHalflengthZ);
263 
266 
267  // PART 1 : Liquid Argon Volumes
268  // ===========================================================================================
269  // get the Tracking Volumes from the LAr Builder
270  //
271  const std::vector<Trk::TrackingVolume*> lArVolumes =
272  m_lArVolumeBuilder->trackingVolumes(*caloDDM,geoAlign);
273 
274  ATH_MSG_INFO(lArVolumes.size()
275  << " volumes retrieved from " << m_lArVolumeBuilder.name());
276 
277  // LAr Barrel part
278  Trk::TrackingVolume* solenoid = lArVolumes[0];
279  Trk::TrackingVolume* solenoidlArPresamplerGap = lArVolumes[1];
280  Trk::TrackingVolume* lArBarrelPresampler = lArVolumes[2];
281  Trk::TrackingVolume* lArBarrel = lArVolumes[3];
282 
283  // LAr Positive Endcap part
284  Trk::TrackingVolume* lArPositiveMBTS = lArVolumes[4];
285  Trk::TrackingVolume* lArPositiveEndcap = lArVolumes[5];
286  Trk::TrackingVolume* lArPositiveHec = lArVolumes[6];
287  Trk::TrackingVolume* lArPositiveFcal = lArVolumes[7];
288  Trk::TrackingVolume* lArPositiveHecFcalCover = lArVolumes[8];
289  // LAr Negative Endcap part
290  Trk::TrackingVolume* lArNegativeMBTS = lArVolumes[9];
291  Trk::TrackingVolume* lArNegativeEndcap = lArVolumes[10];
292  Trk::TrackingVolume* lArNegativeHec = lArVolumes[11];
293  Trk::TrackingVolume* lArNegativeFcal = lArVolumes[12];
294  Trk::TrackingVolume* lArNegativeHecFcalCover = lArVolumes[13];
295  Trk::TrackingVolume* lArPosECPresampler = lArVolumes[14];
296  Trk::TrackingVolume* lArNegECPresampler = lArVolumes[15];
297 
298  // PART 2 : Tile Volumes
299  // ===========================================================================================
300  // get the Tracking Volumes from the Tile Builder
301  std::vector<Trk::TrackingVolume*> tileVolumes =
302  m_tileVolumeBuilder->trackingVolumes(*caloDDM,geoAlign);
303 
304  ATH_MSG_INFO(tileVolumes.size()
305  << " volumes retrieved from " << m_tileVolumeBuilder.name());
306  if (msgLvl(MSG::INFO)) {
307  ATH_MSG_INFO(
308  "--------------- detailed output "
309  "---------------------------------------------------------- ");
310  auto tileVolIter = tileVolumes.begin();
311  auto tileVolIterEnd = tileVolumes.end();
312  for (; tileVolIter != tileVolIterEnd;
313  (*tileVolIter)->screenDump(msg(MSG::VERBOSE)), ++tileVolIter)
314  ;
315  }
316 
317  // Tile Barrel part
318  Trk::TrackingVolume* tileCombined = tileVolumes[0];
319  // Tile Positive Extended Part
320  Trk::TrackingVolume* tilePositiveExtendedBarrel = tileVolumes[1];
321 
322  const Trk::CylinderVolumeBounds* ebBounds =
323  dynamic_cast<const Trk::CylinderVolumeBounds*>(
324  &(tilePositiveExtendedBarrel->volumeBounds()));
325 
326  double rTileMin = ebBounds ? ebBounds->innerRadius() : 2288.;
327  double zTileMin = ebBounds ? tilePositiveExtendedBarrel->center().z() -
328  ebBounds->halflengthZ()
329  : 3559.5;
330 
331  keyDim.emplace_back(rTileMin, zTileMin);
332  for (unsigned int i = 0; i < keyDim.size(); i++) {
333  ATH_MSG_VERBOSE("key dimensions:" << i << ":" << keyDim[i].first << ","
334  << keyDim[i].second);
335  }
336 
337  // The Bounds needed for the Gap Volume creation
338  const Trk::CylinderVolumeBounds* solenoidBounds =
339  dynamic_cast<const Trk::CylinderVolumeBounds*>(
340  &(solenoid->volumeBounds()));
341  if (!solenoidBounds){
342  std::abort();
343  }
344  const Trk::CylinderVolumeBounds* lArBarrelBounds =
345  dynamic_cast<const Trk::CylinderVolumeBounds*>(
346  &(lArBarrel->volumeBounds()));
347  if (!lArBarrelBounds){
348  std::abort();
349  }
350  const Trk::CylinderVolumeBounds* lArPositiveEndcapBounds =
351  dynamic_cast<const Trk::CylinderVolumeBounds*>(
352  &(lArPositiveEndcap->volumeBounds()));
353  if (!lArPositiveEndcapBounds){
354  std::abort();
355  }
356  const Trk::CylinderVolumeBounds* lArNegativeEndcapBounds =
357  dynamic_cast<const Trk::CylinderVolumeBounds*>(
358  &(lArNegativeEndcap->volumeBounds()));
359  if (!lArNegativeEndcapBounds){
360  std::abort();
361  }
362  const Trk::CylinderVolumeBounds* lArPositiveHecBounds =
363  dynamic_cast<const Trk::CylinderVolumeBounds*>(
364  &(lArPositiveHec->volumeBounds()));
365  if (!lArPositiveHecBounds){
366  std::abort();
367  }
368  const Trk::CylinderVolumeBounds* lArPositiveFcalBounds =
369  dynamic_cast<const Trk::CylinderVolumeBounds*>(
370  &(lArPositiveFcal->volumeBounds()));
371  if (!lArPositiveFcalBounds){
372  std::abort();
373  }
374  const Trk::CylinderVolumeBounds* lArNegativeFcalBounds =
375  dynamic_cast<const Trk::CylinderVolumeBounds*>(
376  &(lArNegativeFcal->volumeBounds()));
377  if (!lArNegativeFcalBounds){
378  std::abort();
379  }
380  const Trk::CylinderVolumeBounds* tileCombinedBounds =
381  dynamic_cast<const Trk::CylinderVolumeBounds*>(
382  &(tileCombined->volumeBounds()));
383  if (!tileCombinedBounds){
384  std::abort();
385  }
386 
387  // Create the gap volumes
388  // ======================================================================
389  Trk::TrackingVolume* lArTileCentralSectorGap = nullptr;
390 
391  Trk::TrackingVolume* lArPositiveSectorInnerGap = nullptr;
392  Trk::TrackingVolume* lArPositiveSectorOuterGap = nullptr;
393  Trk::TrackingVolume* lArPositiveSectorOuterGap0 = nullptr;
394  Trk::TrackingVolume* lArCentralPositiveGap = nullptr;
395 
396  Trk::TrackingVolume* lArNegativeSectorInnerGap = nullptr;
397  Trk::TrackingVolume* lArNegativeSectorOuterGap = nullptr;
398  Trk::TrackingVolume* lArNegativeSectorOuterGap0 = nullptr;
399  Trk::TrackingVolume* lArCentralNegativeGap = nullptr;
400 
401  Trk::TrackingVolume* trtSolenoidGap = nullptr;
402 
403  double caloPositiveOuterBoundary = tileCombinedBounds->halflengthZ();
404 
405  double lArPositiveOuterBoundary = lArPositiveFcal->center().z();
406  lArPositiveOuterBoundary += lArPositiveFcalBounds->halflengthZ();
407 
408  // No. 1
409  // building dense volume here
410  Trk::Material tilePositiveSectorInnerGapMaterial =
411  Trk::Material(58., 565., 30.7, 14.6, 0.0025);
412 
413  // calo sensitive volume outer radius/z extent defined (for example) here
414  float caloVolsOuterRadius = tileCombinedBounds->outerRadius();
415  float caloVolsExtendZ = caloPositiveOuterBoundary;
416 
418  // LAr InnerGap sector + beam pipe
419 
420  Trk::Material lArSectorInnerGapMaterial =
421  Trk::Material(361., 1370., 14.5, 7., 0.0009); // ???
422 
423  // create beam pipe volumes for InnerGap/MBTS and return their outer radius
424  float rInnerGapBP = 0.;
425  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> innerGapBP =
426  createBeamPipeVolumes(
427  bpCutouts, keyDim[0].second,
428  // lArPositiveEndcap->center().z()-lArPositiveEndcapBounds->halflengthZ(),
429  keyDim.back().second, "InnerGap", rInnerGapBP);
430 
431  double z = 0.5 * (keyDim.back().second + keyDim[0].second);
432 
433  auto mbtsNegLayers = std::make_unique<std::vector<Trk::Layer*>>();
434  auto mbtsPosLayers = std::make_unique<std::vector<Trk::Layer*>>();
435 
436  if (lArPositiveMBTS && lArNegativeMBTS) {
437  // Disc
438  const Trk::CylinderVolumeBounds* mbtsBounds =
439  dynamic_cast<const Trk::CylinderVolumeBounds*>(
440  &(lArPositiveMBTS->volumeBounds()));
441  if (mbtsBounds && m_buildMBTS) {
442  float rmin = mbtsBounds->innerRadius();
443  float rmax = mbtsBounds->outerRadius();
444  // float d = mbtsBounds->halflengthZ();
445  auto dibo = std::make_shared<Trk::DiscBounds>(rmin, rmax);
446  // MBTS positions
447  Amg::Transform3D mbtsNegZpos =
448  Amg::Transform3D(Amg::Translation3D(lArNegativeMBTS->center()));
449  Amg::Transform3D mbtsPosZpos =
450  Amg::Transform3D(Amg::Translation3D(lArPositiveMBTS->center()));
451  // create the two Layers ( TODO: add trd surface subarray )
452  Trk::DiscLayer* mbtsNegLayer = new Trk::DiscLayer(
453  mbtsNegZpos, dibo,
454  // mbtsNegLayerSurfArray,
455  Trk::HomogeneousLayerMaterial(
456  Trk::MaterialProperties(m_caloMaterial, 1.), 1.),
457  1.);
458  Trk::DiscLayer* mbtsPosLayer = new Trk::DiscLayer(
459  mbtsPosZpos, std::make_shared<Trk::DiscBounds>(*dibo),
460  // mbtsPosLayerSurfArray,
461  Trk::HomogeneousLayerMaterial(
462  Trk::MaterialProperties(m_caloMaterial, 1.), 1.),
463  1. * Gaudi::Units::mm);
464 
465  mbtsNegLayers->push_back(mbtsNegLayer);
466  mbtsPosLayers->push_back(mbtsPosLayer);
467  }
468  }
469 
470  // building inner gap
471  auto lArG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
472  rInnerGapBP,
473  // lArPositiveEndcapBounds->outerRadius(),
474  keyDim[0].first, 0.5 * (keyDim.back().second - keyDim[0].second));
475 
476  auto lArG1P =
477  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
478  lArPositiveSectorInnerGap = new Trk::TrackingVolume(
479  std::move(lArG1P), std::make_shared<Trk::CylinderVolumeBounds>(*lArG1Bounds),
480  lArSectorInnerGapMaterial, std::move(mbtsPosLayers),
481  "Calo::GapVolumes::LAr::PositiveSectorInnerGap");
482 
483  auto lArG1N =
484  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
485  lArNegativeSectorInnerGap = new Trk::TrackingVolume(
486  std::move(lArG1N),
487  std::move(lArG1Bounds),
488  lArSectorInnerGapMaterial,
489  std::move(mbtsNegLayers), "Calo::GapVolumes::LAr::NegativeSectorInnerGap");
490 
491  // glue InnerGap with beam pipe volumes
492  Trk::TrackingVolume* positiveInnerGap = nullptr;
493  if (innerGapBP.first) {
494  std::vector<Trk::TrackingVolume*> volsInnerGap;
495  volsInnerGap.push_back(innerGapBP.first);
496  volsInnerGap.push_back(lArPositiveSectorInnerGap);
497  positiveInnerGap = m_trackingVolumeCreator->createContainerTrackingVolume(
498  volsInnerGap, m_caloMaterial, "Calo::Container::PositiveInnerGap");
499  } else
500  positiveInnerGap = lArPositiveSectorInnerGap;
501 
502  Trk::TrackingVolume* negativeInnerGap = nullptr;
503  if (innerGapBP.second) {
504  std::vector<Trk::TrackingVolume*> volsInnerGap;
505  volsInnerGap.push_back(innerGapBP.second);
506  volsInnerGap.push_back(lArNegativeSectorInnerGap);
507  negativeInnerGap = m_trackingVolumeCreator->createContainerTrackingVolume(
508  volsInnerGap, m_caloMaterial, "Calo::Container::NegativeInnerGap");
509  } else
510  negativeInnerGap = lArNegativeSectorInnerGap;
511 
512  // glue MBTS volumes with ID
513  std::vector<Trk::TrackingVolume*> inBufferVolumes;
514  inBufferVolumes.push_back(negativeInnerGap);
515  inBufferVolumes.push_back(innerVol);
516  inBufferVolumes.push_back(positiveInnerGap);
517 
518  Trk::TrackingVolume* inDetEnclosed =
519  m_trackingVolumeCreator->createContainerTrackingVolume(
520  inBufferVolumes, m_caloMaterial,
521  "Calo::Container::EnclosedInnerDetector");
522 
523  ATH_MSG_DEBUG(" Inner detector enclosed (MBTS volumes)");
524 
526  // LAr endcap sector including the beam pipe
527  // create beam pipe volumes for Endcap and return their outer radius
528  float rEndcapBP = 0.;
529  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> endcapBP =
530  createBeamPipeVolumes(bpCutouts, keyDim.back().second,
531  lArPositiveEndcap->center().z() +
532  lArPositiveEndcapBounds->halflengthZ(),
533  "Endcap", rEndcapBP);
534 
535  // build lAr vessel around EC Presampler
536  const Trk::CylinderVolumeBounds* ecpBounds =
537  dynamic_cast<const Trk::CylinderVolumeBounds*>(
538  &(lArPosECPresampler->volumeBounds()));
539  if (!ecpBounds){
540  std::abort();
541  }
542 
543  float ecpHz = ecpBounds->halflengthZ();
544  float ecpRmin = ecpBounds->innerRadius();
545  float ecpRmax = ecpBounds->outerRadius();
546 
547  auto ecpPos = std::make_unique<Amg::Transform3D>(lArPosECPresampler->transform());
548  auto ecpNeg = std::make_unique<Amg::Transform3D>(lArNegECPresampler->transform());
549 
550  auto ecpUpBounds = std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
551  auto ecpDownBounds = std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
552 
553  Trk::TrackingVolume* ecPresamplerCoverPos = new Trk::TrackingVolume(
554  std::make_unique<Amg::Transform3D>(*ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpUpBounds),
555  m_Al, nullptr, nullptr,
556  "Calo::GapVolumes::LAr::PositiveECPresamplerCover");
557  Trk::TrackingVolume* ecPresamplerCoverNeg = new Trk::TrackingVolume(
558  std::make_unique<Amg::Transform3D>(*ecpNeg),
559  std::move(ecpUpBounds), m_Al, nullptr, nullptr,
560  "Calo::GapVolumes::LAr::NegativeECPresamplerCover");
561  Trk::TrackingVolume* ecPresamplerInnerPos = new Trk::TrackingVolume(
562  std::move(ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpDownBounds),
563  m_Al, nullptr,
564  nullptr, "Calo::GapVolumes::LAr::PositiveECPresamplerInner");
565  Trk::TrackingVolume* ecPresamplerInnerNeg = new Trk::TrackingVolume(
566  std::move(ecpNeg),
567  std::move(ecpDownBounds),
568  m_Al, nullptr,
569  nullptr, "Calo::GapVolumes::LAr::NegativeECPresamplerInner");
570 
571  // glue EC presampler radially
572  std::vector<Trk::TrackingVolume*> volsECP;
573  volsECP.push_back(ecPresamplerInnerPos);
574  volsECP.push_back(lArPosECPresampler);
575  volsECP.push_back(ecPresamplerCoverPos);
576  Trk::TrackingVolume* positiveECP =
577  m_trackingVolumeCreator->createContainerTrackingVolume(
578  volsECP, m_caloMaterial, "Calo::Container::PositiveECPresamplerR");
579  std::vector<Trk::TrackingVolume*> volsECN;
580  volsECN.push_back(ecPresamplerInnerNeg);
581  volsECN.push_back(lArNegECPresampler);
582  volsECN.push_back(ecPresamplerCoverNeg);
583  Trk::TrackingVolume* negativeECP =
584  m_trackingVolumeCreator->createContainerTrackingVolume(
585  volsECN, m_caloMaterial, "Calo::Container::NegativeECPresamplerR");
586 
587  // add surrounding buffers
588  z = lArPosECPresampler->center().z() - ecpHz;
589  float z1 = lArPosECPresampler->center().z() + ecpHz;
590  float z2 =
591  lArPositiveEndcap->center().z() - lArPositiveEndcapBounds->halflengthZ();
592 
593  auto ecIPos = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
594  Amg::Vector3D(0., 0., 0.5 * (z + keyDim.back().second))));
595 
596  auto ecINeg = std::make_unique<Amg::Transform3D>(Amg::Translation3D(
597  Amg::Vector3D(0., 0., -0.5 * (z + keyDim.back().second))));
598 
599  auto ecpIBounds = std::make_shared<Trk::CylinderVolumeBounds>(
600  rEndcapBP, keyDim.back().first, 0.5 * (z - keyDim.back().second));
601 
602  auto ecOPos = std::make_unique<Amg::Transform3D>(
603  Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (z1 + z2))));
604 
605  auto ecONeg = std::make_unique<Amg::Transform3D>(
606  Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (z1 + z2))));
607 
608  auto ecpOBounds = std::make_shared<Trk::CylinderVolumeBounds>(
609  rEndcapBP, keyDim.back().first, 0.5 * (z2 - z1));
610 
611  Trk::TrackingVolume* ecPresamplerInPos = new Trk::TrackingVolume(
612  std::move(ecIPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpIBounds),
613  m_Ar, nullptr, nullptr,
614  "Calo::GapVolumes::LAr::PositiveECPresamplerIn");
615  Trk::TrackingVolume* ecPresamplerInNeg = new Trk::TrackingVolume(
616  std::move(ecINeg), std::move(ecpIBounds),
617  m_Ar, nullptr, nullptr,
618  "Calo::GapVolumes::LAr::NegativeECPresamplerIn");
619  Trk::TrackingVolume* ecPresamplerOutPos = new Trk::TrackingVolume(
620  std::move(ecOPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpOBounds),
621  m_Ar, nullptr, nullptr,
622  "Calo::GapVolumes::LAr::PositiveECPresamplerOut");
623  Trk::TrackingVolume* ecPresamplerOutNeg = new Trk::TrackingVolume(
624  std::move(ecONeg), std::move(ecpOBounds),
625  m_Ar, nullptr, nullptr,
626  "Calo::GapVolumes::LAr::NegativeECPresamplerOut");
627 
628  // glue EC presampler in z
629  std::vector<Trk::TrackingVolume*> volECP;
630  volECP.push_back(ecPresamplerInPos);
631  volECP.push_back(positiveECP);
632  volECP.push_back(ecPresamplerOutPos);
633  Trk::TrackingVolume* positiveEP =
634  m_trackingVolumeCreator->createContainerTrackingVolume(
635  volECP, m_caloMaterial, "Calo::Container::PositiveECPresampler");
636  std::vector<Trk::TrackingVolume*> volECN;
637  volECN.push_back(ecPresamplerOutNeg);
638  volECN.push_back(negativeECP);
639  volECN.push_back(ecPresamplerInNeg);
640  Trk::TrackingVolume* negativeEP =
641  m_trackingVolumeCreator->createContainerTrackingVolume(
642  volECN, m_caloMaterial, "Calo::Container::NegativeECPresampler");
643 
644  // build lAr vessel around EMEC
645  ecpHz = lArPositiveEndcapBounds->halflengthZ();
646  ecpRmin = lArPositiveEndcapBounds->innerRadius();
647  ecpRmax = lArPositiveEndcapBounds->outerRadius();
648 
649  auto ecPos =
650  std::make_unique<Amg::Transform3D>(lArPositiveEndcap->transform());
651  auto ecNeg =
652  std::make_unique<Amg::Transform3D>(lArNegativeEndcap->transform());
653 
654  auto ecUpBounds =
655  std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
656  auto ecDownBounds =
657  std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
658 
659  Trk::TrackingVolume* ecCoverPos = new Trk::TrackingVolume(
660  std::make_unique<Amg::Transform3D>(*ecPos),
661  std::make_shared<Trk::CylinderVolumeBounds>(*ecUpBounds),
662  m_Ar, nullptr, nullptr,
663  "Calo::GapVolumes::LAr::PositiveEndcapCover");
664  Trk::TrackingVolume* ecCoverNeg = new Trk::TrackingVolume(
665  std::make_unique<Amg::Transform3D>(*ecNeg),
666  std::move(ecUpBounds),
667  m_Ar, nullptr, nullptr,
668  "Calo::GapVolumes::LAr::NegativeEndcapCover");
669  Trk::TrackingVolume* ecInnerPos = new Trk::TrackingVolume(
670  std::move(ecPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecDownBounds),
671  m_Al, nullptr,
672  nullptr, "Calo::GapVolumes::LAr::PositiveEndcapInner");
673  Trk::TrackingVolume* ecInnerNeg = new Trk::TrackingVolume(
674  std::move(ecNeg),
675  std::move(ecDownBounds),
676  m_Al, nullptr,
677  nullptr, "Calo::GapVolumes::LAr::NegativeEndcapInner");
678 
679  // glue EMEC radially
680  std::vector<Trk::TrackingVolume*> volsEC;
681  volsEC.push_back(ecInnerPos);
682  volsEC.push_back(lArPositiveEndcap);
683  volsEC.push_back(ecCoverPos);
684  Trk::TrackingVolume* positiveEC =
685  m_trackingVolumeCreator->createContainerTrackingVolume(
686  volsEC, m_caloMaterial, "Calo::Container::PositiveEndcapR");
687  std::vector<Trk::TrackingVolume*> volsEN;
688  volsEN.push_back(ecInnerNeg);
689  volsEN.push_back(lArNegativeEndcap);
690  volsEN.push_back(ecCoverNeg);
691  Trk::TrackingVolume* negativeEC =
692  m_trackingVolumeCreator->createContainerTrackingVolume(
693  volsEN, m_caloMaterial, "Calo::Container::NegativeEndcapR");
694 
695  // glue presampler with EMEC
696  std::vector<Trk::TrackingVolume*> volEEP;
697  volEEP.push_back(positiveEP);
698  volEEP.push_back(positiveEC);
699  Trk::TrackingVolume* positiveEEP =
700  m_trackingVolumeCreator->createContainerTrackingVolume(
701  volEEP, m_caloMaterial, "Calo::Container::PositiveEMEC");
702  std::vector<Trk::TrackingVolume*> volEEN;
703  volEEN.push_back(negativeEC);
704  volEEN.push_back(negativeEP);
705  Trk::TrackingVolume* negativeEEP =
706  m_trackingVolumeCreator->createContainerTrackingVolume(
707  volEEN, m_caloMaterial, "Calo::Container::NegativeEMEC");
708 
709  // glue EMEC sector with beam pipe volumes
710 
711  std::vector<Trk::TrackingVolume*> volsEndcapPos;
712  if (endcapBP.first)
713  volsEndcapPos.push_back(endcapBP.first);
714  volsEndcapPos.push_back(positiveEEP);
715 
716  std::unique_ptr<Trk::TrackingVolume> positiveEndcap(
717  m_trackingVolumeCreator->createContainerTrackingVolume(
718  volsEndcapPos, m_caloMaterial, "Calo::Container::PositiveEndcap"));
719 
720  std::vector<Trk::TrackingVolume*> volsEndcapNeg;
721  if (endcapBP.second)
722  volsEndcapNeg.push_back(endcapBP.second);
723  volsEndcapNeg.push_back(negativeEEP);
724 
725  std::unique_ptr<Trk::TrackingVolume> negativeEndcap(
726  m_trackingVolumeCreator->createContainerTrackingVolume(
727  volsEndcapNeg, m_caloMaterial, "Calo::Container::NegativeEndcap"));
728 
730  // Hec sector + beam pipe + lAr cover
731  // create beam pipe volumes for Hec and return their outer radius
732  float rHecBP = 0.;
733  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> hecBP =
734  createBeamPipeVolumes(
735  bpCutouts,
736  lArPositiveHec->center().z() - lArPositiveHecBounds->halflengthZ(),
737  lArPositiveHec->center().z() + lArPositiveHecBounds->halflengthZ(),
738  "Hec", rHecBP);
739  // HecInnerGap (new gap volume )
740  Trk::Material lArHecInnerGapMaterial =
741  Trk::Material(390., 1223., 18., 9., 0.0014);
742 
743  // create the Bounds
744  auto lArHecInnerGapBounds =
745  std::make_shared<Trk::CylinderVolumeBounds>(rHecBP, lArPositiveHecBounds->innerRadius(),
746  lArPositiveHecBounds->halflengthZ());
747 
748  auto lArHecPos = std::make_unique<Amg::Transform3D>(
749  Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveHec->center().z())));
750  auto lArHecNeg = std::make_unique<Amg::Transform3D>(
751  Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeHec->center().z())));
752 
753  Trk::TrackingVolume* lArPositiveHecInnerGap = new Trk::TrackingVolume(
754  std::make_unique<Amg::Transform3D>(*lArHecPos),
755  lArHecInnerGapBounds, m_Al, nullptr, nullptr,
756  "Calo::GapVolumes::LAr::PositiveHecInnerGap");
757 
758  Trk::TrackingVolume* lArNegativeHecInnerGap = new Trk::TrackingVolume(
759  std::make_unique<Amg::Transform3D>(*lArHecNeg),
760  std::make_shared<Trk::CylinderVolumeBounds>(*lArHecInnerGapBounds),
761  m_Al, nullptr, nullptr,
762  "Calo::GapVolumes::LAr::NegativeHecInnerGap");
763  // create the Bounds
764  auto lArHecOuterGapBounds =
765  std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->outerRadius(),
766  keyDim.back().first,
767  lArPositiveHecBounds->halflengthZ());
768 
769  Trk::TrackingVolume* lArPositiveHecOuterGap = new Trk::TrackingVolume(
770  std::move(lArHecPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArHecOuterGapBounds),
771  m_Ar, nullptr,
772  nullptr, "Calo::GapVolumes::LAr::PositiveHecOuterGap");
773 
774  Trk::TrackingVolume* lArNegativeHecOuterGap = new Trk::TrackingVolume(
775  std::move(lArHecNeg),
776  std::move(lArHecOuterGapBounds), m_Ar,
777  nullptr, nullptr, "Calo::GapVolumes::LAr::NegativeHecOuterGap");
778 
779  // glue Hec sector with beam pipe volumes
780 
781  std::vector<Trk::TrackingVolume*> volsHecPos;
782  if (hecBP.first)
783  volsHecPos.push_back(hecBP.first);
784  volsHecPos.push_back(lArPositiveHecInnerGap);
785  volsHecPos.push_back(lArPositiveHec);
786  volsHecPos.push_back(lArPositiveHecOuterGap);
787 
788  std::unique_ptr<Trk::TrackingVolume> positiveHec(
789  m_trackingVolumeCreator->createContainerTrackingVolume(
790  volsHecPos, m_caloMaterial, "Calo::Container::PositiveHec"));
791 
792  std::vector<Trk::TrackingVolume*> volsHecNeg;
793  if (hecBP.second){
794  volsHecNeg.push_back(hecBP.second);
795  }
796  volsHecNeg.push_back(lArNegativeHecInnerGap);
797  volsHecNeg.push_back(lArNegativeHec);
798  volsHecNeg.push_back(lArNegativeHecOuterGap);
799 
800  std::unique_ptr<Trk::TrackingVolume> negativeHec(
801  m_trackingVolumeCreator->createContainerTrackingVolume(
802  volsHecNeg, m_caloMaterial, "Calo::Container::NegativeHec"));
803 
805  // Fcal sector + beam pipe + lAr cover
806 
807  // create beam pipe volumes for Fcal and return their outer radius
808  float rFcalBP = 0.;
809  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> fcalBP =
810  createBeamPipeVolumes(
811  bpCutouts,
812  lArPositiveFcal->center().z() - lArPositiveFcalBounds->halflengthZ(),
813  lArPositiveFcal->center().z() + lArPositiveFcalBounds->halflengthZ(),
814  "Fcal", rFcalBP);
815  // FcalInnerGap (new gap volume )
816  // Trk::Material lArFcalInnerGapMaterial = Trk::Material(390.,
817  // 1223., 40.,18., 0.0014);
818 
819  if (rFcalBP > lArPositiveFcalBounds->innerRadius()) {
820  ATH_MSG_ERROR("PROBLEM : beam pipe collide with Fcal:"
821  << rFcalBP << ">" << lArPositiveFcalBounds->innerRadius()
822  << ", abort");
823  return nullptr;
824  }
825 
826  // create the Bounds
827  auto lArFcalInnerGapBounds =
828  std::make_shared<Trk::CylinderVolumeBounds>(rFcalBP,
829  lArPositiveFcalBounds->innerRadius(),
830  lArPositiveFcalBounds->halflengthZ());
831 
832  auto lArFcalPos = std::make_unique<Amg::Transform3D>(
833  Amg::Translation3D(Amg::Vector3D(0., 0., lArPositiveFcal->center().z())));
834  auto lArFcalNeg = std::make_unique<Amg::Transform3D>(
835  Amg::Translation3D(Amg::Vector3D(0., 0., lArNegativeFcal->center().z())));
836 
837  Trk::TrackingVolume* lArPositiveFcalInnerGap = new Trk::TrackingVolume(
838  std::make_unique<Amg::Transform3D>(*lArFcalPos),
839  std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalInnerGapBounds),
840  m_Al, nullptr, nullptr,
841  "Calo::GapVolumes::LAr::PositiveFcalInnerGap");
842 
843  Trk::TrackingVolume* lArNegativeFcalInnerGap = new Trk::TrackingVolume(
844  std::make_unique<Amg::Transform3D>(*lArFcalNeg),
845  std::move(lArFcalInnerGapBounds), m_Al, nullptr,
846  nullptr, "Calo::GapVolumes::LAr::NegativeFcalInnerGap");
847 
848  // create the Bounds
849  auto lArFcalOuterGapBounds =
850  std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->outerRadius(),
851  keyDim.back().first,
852  lArPositiveFcalBounds->halflengthZ());
853 
854  Trk::TrackingVolume* lArPositiveFcalOuterGap = new Trk::TrackingVolume(
855  std::move(lArFcalPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalOuterGapBounds),
856  m_Ar, nullptr, nullptr, "Calo::GapVolumes::LAr::PositiveFcalOuterGap");
857 
858  Trk::TrackingVolume* lArNegativeFcalOuterGap = new Trk::TrackingVolume(
859  std::move(lArFcalNeg), std::move(lArFcalOuterGapBounds), m_Ar,
860  nullptr, nullptr, "Calo::GapVolumes::LAr::NegativeFcalOuterGap");
861 
862  // glue Fcal sector with beam pipe volumes
863 
864  std::vector<Trk::TrackingVolume*> volsFcalPos;
865  if (fcalBP.first){
866  volsFcalPos.push_back(fcalBP.first);
867  }
868  volsFcalPos.push_back(lArPositiveFcalInnerGap);
869  volsFcalPos.push_back(lArPositiveFcal);
870  volsFcalPos.push_back(lArPositiveHecFcalCover);
871  volsFcalPos.push_back(lArPositiveFcalOuterGap);
872 
873  std::unique_ptr<Trk::TrackingVolume> positiveFcal(
874  m_trackingVolumeCreator->createContainerTrackingVolume(
875  volsFcalPos, m_caloMaterial, "Calo::Container::PositiveFcal"));
876 
877  std::vector<Trk::TrackingVolume*> volsFcalNeg;
878  if (fcalBP.second){
879  volsFcalNeg.push_back(fcalBP.second);
880  }
881  volsFcalNeg.push_back(lArNegativeFcalInnerGap);
882  volsFcalNeg.push_back(lArNegativeFcal);
883  volsFcalNeg.push_back(lArNegativeHecFcalCover);
884  volsFcalNeg.push_back(lArNegativeFcalOuterGap);
885 
886  std::unique_ptr<Trk::TrackingVolume> negativeFcal(
887  m_trackingVolumeCreator->createContainerTrackingVolume(
888  volsFcalNeg, m_caloMaterial, "Calo::Container::NegativeFcal"));
889 
891  // Outer endcap sector + beam pipe
892 
893  // create beam pipe volumes for Outer sector and return their outer radius
894  float rOutBP = 0.;
895  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> outBP =
896  createBeamPipeVolumes(bpCutouts, lArPositiveOuterBoundary,
897  caloPositiveOuterBoundary, "Outer", rOutBP);
898 
899  Trk::Material lArSectorOuterGapMat =
900  Trk::Material(20.5, 723., 64., 28., 0.0084);
901 
902  auto lArSectorOuterG0Bounds =
903  std::make_shared<Trk::CylinderVolumeBounds>(
904  rOutBP, 430.,
905  // lArPositiveEndcapBounds->outerRadius(),
906  0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
907 
908  auto lArSectorOuterG1Bounds =
909  std::make_shared<Trk::CylinderVolumeBounds>(
910  430., keyDim.back().first,
911  // lArPositiveEndcapBounds->outerRadius(),
912  0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
913 
914  z = 0.5 * (caloPositiveOuterBoundary + lArPositiveOuterBoundary);
915 
916  auto lArSecOutG1P =
917  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
918  auto lArSecOutG0P =
919  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
920 
921  lArPositiveSectorOuterGap0 = new Trk::TrackingVolume(
922  std::move(lArSecOutG0P), std::make_shared<Trk::CylinderVolumeBounds>(*lArSectorOuterG0Bounds),
923  lArSectorOuterGapMat, nullptr,
924  nullptr, "Calo::GapVolumes::LAr::PositiveSectorOuterGap0");
925 
926  lArPositiveSectorOuterGap = new Trk::TrackingVolume(
927  std::move(lArSecOutG1P), std::make_shared<Trk::CylinderVolumeBounds> (*lArSectorOuterG1Bounds),
928  m_Ar, nullptr, nullptr,
929  "Calo::GapVolumes::LAr::PositiveSectorOuterGap");
930 
931  auto lArSecOutG1N =
932  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
933  auto lArSecOutG0N =
934  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
935 
936  lArNegativeSectorOuterGap0 =
937  new Trk::TrackingVolume(std::move(lArSecOutG0N),
938  std::move(lArSectorOuterG0Bounds),
939  lArSectorOuterGapMat, nullptr, nullptr,
940  "Calo::GapVolumes::LAr::NegativeSectorOuterGap0");
941 
942  lArNegativeSectorOuterGap = new Trk::TrackingVolume(
943  std::move(lArSecOutG1N),
944  std::move(lArSectorOuterG1Bounds),
945  m_Ar, nullptr,
946  nullptr, "Calo::GapVolumes::LAr::NegativeSectorOuterGap");
947 
948  // glue OuterGap with beam pipe volumes
949  std::vector<Trk::TrackingVolume*> volsOuterGapP;
950  if (outBP.first){
951  volsOuterGapP.push_back(outBP.first);
952  }
953  volsOuterGapP.push_back(lArPositiveSectorOuterGap0);
954  volsOuterGapP.push_back(lArPositiveSectorOuterGap);
955  std::unique_ptr<Trk::TrackingVolume> positiveOuterGap(
956  m_trackingVolumeCreator->createContainerTrackingVolume(
957  volsOuterGapP, m_caloMaterial, "Calo::Container::PositiveOuterGap"));
958 
959  std::vector<Trk::TrackingVolume*> volsOuterGapN;
960  if (outBP.second){
961  volsOuterGapN.push_back(outBP.second);
962  }
963  volsOuterGapN.push_back(lArNegativeSectorOuterGap0);
964  volsOuterGapN.push_back(lArNegativeSectorOuterGap);
965  std::unique_ptr<Trk::TrackingVolume> negativeOuterGap(
966  m_trackingVolumeCreator->createContainerTrackingVolume(
967  volsOuterGapN, m_caloMaterial, "Calo::Container::NegativeOuterGap"));
968 
969  ATH_MSG_DEBUG("Endcap volumes ready");
970 
971  // ++ (ii) lArNegativeSector
972  Trk::TrackingVolume* lArNegativeSector = nullptr;
973  // +++ has 4 sub volumes in Z
974  std::vector<Trk::TrackingVolume*> lArNegativeSectorVolumes;
975  // +++ (A) -> Outer sector
976  lArNegativeSectorVolumes.push_back(negativeOuterGap.release());
977  // +++ (B) -> Fcal sector
978  lArNegativeSectorVolumes.push_back(negativeFcal.release());
979  // +++ (C) -> Hec sector
980  lArNegativeSectorVolumes.push_back(negativeHec.release());
981  // +++ (D) -> Endcap sector
982  lArNegativeSectorVolumes.push_back(negativeEndcap.release());
983  // +++ all exists : create super volume (ii)
984  lArNegativeSector = m_trackingVolumeCreator->createContainerTrackingVolume(
985  lArNegativeSectorVolumes, m_caloMaterial,
986  "Calo::LAr::Container::NegativeSector");
987 
988  // ++ (ii) lArPositiveSector
989  Trk::TrackingVolume* lArPositiveSector = nullptr;
990  // +++ has 4 sub volumes in Z
991  std::vector<Trk::TrackingVolume*> lArPositiveSectorVolumes;
992  // +++ (A) -> Endcap sector
993  lArPositiveSectorVolumes.push_back(positiveEndcap.release());
994  // +++ (B) -> Hec sector
995  lArPositiveSectorVolumes.push_back(positiveHec.release());
996  // +++ (C) -> Fcal sector
997  lArPositiveSectorVolumes.push_back(positiveFcal.release());
998  // +++ (D) -> OuterGap
999  lArPositiveSectorVolumes.push_back(positiveOuterGap.release());
1000  // +++ all exists : create super volume (ii)
1001  lArPositiveSector = m_trackingVolumeCreator->createContainerTrackingVolume(
1002  lArPositiveSectorVolumes, m_caloMaterial,
1003  "Calo::LAr::Container::PositiveSector");
1004 
1006  // central LAr barrel
1007  //
1008  // solenoid gap
1009  auto trtSolGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1010  keyDim[0].first, solenoidBounds->innerRadius(),
1011  solenoidBounds->halflengthZ());
1012 
1013  // solenoid gap is not completely empty
1014  Trk::Material solGapMat(535., 2871., 18.6, 9.1, 0.00038);
1015 
1016  trtSolenoidGap =
1017  new Trk::TrackingVolume(nullptr, std::move(trtSolGapBounds), solGapMat, nullptr,
1018  nullptr, "Calo::GapVolumes::SolenoidGap");
1019 
1020  auto lArTileCentralG1Bounds =
1021  std::make_shared<Trk::CylinderVolumeBounds>(lArBarrelBounds->outerRadius(),
1022  tileCombinedBounds->innerRadius(),
1023  lArBarrelBounds->halflengthZ());
1024 
1025  lArTileCentralSectorGap = new Trk::TrackingVolume(
1026  nullptr, std::move(lArTileCentralG1Bounds), m_Ar, nullptr, nullptr,
1027  "Calo::GapVolumes::LArTileCentralSectorGap");
1028 
1029  Trk::TrackingVolume* lArCentralBarrelSector = nullptr;
1030  // ++ has 6 sub volumes in R
1031  std::vector<Trk::TrackingVolume*> lArCentralBarrelSectorVolumes;
1032  // ++++ (a) -> solenoid gap
1033  lArCentralBarrelSectorVolumes.push_back(trtSolenoidGap);
1034  // ++++ (b) -> solenoid (exists already)
1035  lArCentralBarrelSectorVolumes.push_back(solenoid);
1036  // ++++ (c) -> solenoidlArPresamplerGap (exists already)
1037  lArCentralBarrelSectorVolumes.push_back(solenoidlArPresamplerGap);
1038  // ++++ (d) -> lArBarrelPresampler (exists already)
1039  lArCentralBarrelSectorVolumes.push_back(lArBarrelPresampler);
1040  // ++++ (e) -> lArBarrel (exists already)
1041  lArCentralBarrelSectorVolumes.push_back(lArBarrel);
1042  // ++++ (f) -> lArTile gap
1043  lArCentralBarrelSectorVolumes.push_back(lArTileCentralSectorGap);
1044  // ++++ all sub volumes exist: build the super volume
1045  lArCentralBarrelSector =
1046  m_trackingVolumeCreator->createContainerTrackingVolume(
1047  lArCentralBarrelSectorVolumes, m_caloMaterial,
1048  "Calo::Containers::LAr::CentralBarrelSector", false, true);
1050  // side buffers
1051  // the Tile Crack volume (TileGap3, enum 17) inserted here
1052  // binned material for Crack : steering in binEta
1053  // TODO turn into 2D binned array
1054  std::vector<Trk::IdentifiedMaterial> matCrack;
1055  // layer material can be adjusted here
1056  int baseID = Trk::GeometrySignature(Trk::Calo) * 1000 + 17;
1057  matCrack.emplace_back(std::make_shared<Trk::Material>(m_Scint), baseID);
1058  matCrack.emplace_back(std::make_shared<Trk::Material>(m_caloMaterial), -1);
1059  matCrack.emplace_back(std::make_shared<Trk::Material>(m_Al), -1);
1060  //
1061  double etadist;
1062  // if TileGap3 goes above 1.6 in eta - it's RUN3 geometry
1063  int nbins =
1064  (caloDDM->is_in(1.65, 0.0, CaloCell_ID::TileGap3, etadist)) ? 6 : 3;
1065  auto bun = Trk::BinUtility(nbins, -1.8, -1.2, Trk::open, Trk::binEta);
1066  auto bup = Trk::BinUtility(nbins, 1.2, 1.8, Trk::open, Trk::binEta);
1067  // array of indices
1068  std::vector<std::vector<size_t>> indexP;
1069  std::vector<std::vector<size_t>> indexN;
1070  // binned material for LAr : layer depth per eta bin
1071  std::vector<Trk::BinUtility> layDN(bun.bins());
1072  std::vector<Trk::BinUtility> layUP(bup.bins());
1073  double crackZ1 = 3532.;
1074  double crackZ2 = 3540.;
1075  // construct bin utilities
1076  std::vector<float> steps;
1077  for (unsigned int i = 0; i < bup.bins(); i++) {
1078  steps.clear();
1079  std::vector<size_t> indx;
1080  indx.clear();
1081  steps.push_back(crackZ1);
1082  indx.push_back(i < bup.bins() - 1 ? 0 : 1);
1083  steps.push_back(crackZ2);
1084  indx.push_back(2);
1085  steps.push_back(keyDim.back().second);
1086  Trk::BinUtility zBU = Trk::BinUtility(steps, Trk::open, Trk::binZ);
1087  layUP[i] = zBU;
1088  indexP.push_back(indx);
1089  }
1090 
1091  const Trk::BinnedMaterial crackBinPos(m_crackMaterial, bup, layUP, indexP,
1092  matCrack);
1093 
1094  auto crackBoundsPos = std::make_shared<Trk::CylinderVolumeBounds>(
1095  keyDim[0].first, tileCombinedBounds->innerRadius(),
1096  0.5 * (keyDim.back().second - crackZ1));
1097  z = 0.5 * (keyDim.back().second + crackZ1);
1098  auto crackPosTransform =
1099  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
1100 
1101  Trk::AlignableTrackingVolume* crackPos = new Trk::AlignableTrackingVolume(
1102  std::move(crackPosTransform), crackBoundsPos, crackBinPos, 17,
1103  "Calo::Detectors::Tile::CrackPos");
1104 
1105  for (unsigned int i = 0; i < bun.bins(); i++) {
1106  steps.clear();
1107  std::vector<size_t> indx;
1108  indx.clear();
1109  steps.push_back(-keyDim.back().second);
1110  indx.push_back(2);
1111  steps.push_back(-crackZ2);
1112  indx.push_back(i > 0 ? 0 : 1);
1113  steps.push_back(-crackZ1);
1114  Trk::BinUtility zBU = Trk::BinUtility(steps, Trk::open, Trk::binZ);
1115  layDN[i] = zBU;
1116  indexN.push_back(indx);
1117  }
1118 
1119  const Trk::BinnedMaterial crackBinNeg(m_crackMaterial, bun, layDN, indexN, matCrack);
1120 
1121  auto crackNegTransform =
1122  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
1123 
1124  Trk::AlignableTrackingVolume* crackNeg = new Trk::AlignableTrackingVolume(
1125  std::move(crackNegTransform),
1126  std::make_shared<Trk::CylinderVolumeBounds>(*crackBoundsPos), crackBinNeg, 17,
1127  "Calo::Detectors::Tile::CrackNeg");
1129 
1130  auto lArCentralG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
1131  keyDim[0].first, tileCombinedBounds->innerRadius(),
1132  0.5 * (crackZ1 - lArBarrelBounds->halflengthZ()));
1133 
1134  z = 0.5 * (crackZ1 + lArBarrelBounds->halflengthZ());
1135  auto lArCentralG1P =
1136  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., z)));
1137 
1138  lArCentralPositiveGap = new Trk::TrackingVolume(
1139  std::move(lArCentralG1P),
1140  std::make_shared<Trk::CylinderVolumeBounds>(*lArCentralG1Bounds), m_Ar, nullptr, nullptr,
1141  "Calo::GapVolumes::LArCentralPositiveGap");
1142 
1143  auto lArCentralG1N =
1144  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -z)));
1145 
1146  lArCentralNegativeGap = new Trk::TrackingVolume(
1147  std::move(lArCentralG1N),
1148  std::move(lArCentralG1Bounds),
1149  m_Ar, nullptr,
1150  nullptr, "Calo::GapVolumes::LArCentralNegativeGap");
1151 
1152  // glue laterally
1153  Trk::TrackingVolume* lArCentralSector = nullptr;
1154  // ++ has 5 sub volumes in z
1155  std::vector<Trk::TrackingVolume*> lArCentralSectorVolumes;
1156  // ++++ (a) -> negative crack
1157  lArCentralSectorVolumes.push_back(crackNeg);
1158  // ++++ (b) -> negative gap
1159  lArCentralSectorVolumes.push_back(lArCentralNegativeGap);
1160  // ++++ (c) -> central barrel
1161  lArCentralSectorVolumes.push_back(lArCentralBarrelSector);
1162  // ++++ (d) -> positive gap
1163  lArCentralSectorVolumes.push_back(lArCentralPositiveGap);
1164  // ++++ (e) -> positive crack
1165  lArCentralSectorVolumes.push_back(crackPos);
1166  // ++++ all sub volumes exist: build the super volume
1167  lArCentralSector = m_trackingVolumeCreator->createContainerTrackingVolume(
1168  lArCentralSectorVolumes, m_caloMaterial,
1169  "Calo::Containers::LAr::CentralSector");
1170 
1171  // glue with ID sector
1172  Trk::TrackingVolume* caloCentralSector = nullptr;
1173  // ++ has 2 sub volumes in R
1174  std::vector<Trk::TrackingVolume*> caloCentralSectorVolumes;
1175  // ++++ (a) -> ID sector
1176  caloCentralSectorVolumes.push_back(inDetEnclosed);
1177  // ++++ (b) -> LAr sector
1178  caloCentralSectorVolumes.push_back(lArCentralSector);
1179  // ++++ all sub volumes exist: build the super volume
1180  caloCentralSector = m_trackingVolumeCreator->createContainerTrackingVolume(
1181  caloCentralSectorVolumes, m_caloMaterial,
1182  "Calo::Containers::CaloCentralSector");
1183 
1185 
1186  // glue laterally with endcaps
1187  Trk::TrackingVolume* lArCombined = nullptr;
1188  // ++ has 3 sub volumes in z
1189  std::vector<Trk::TrackingVolume*> lArCombinedVolumes;
1190  // ++++ (a) -> negative endcap
1191  lArCombinedVolumes.push_back(lArNegativeSector);
1192  // ++++ (b) -> barrel
1193  lArCombinedVolumes.push_back(caloCentralSector);
1194  // ++++ (a) -> positive endcap
1195  lArCombinedVolumes.push_back(lArPositiveSector);
1196  // ++++ all sub volumes exist: build the super volume
1197  lArCombined = m_trackingVolumeCreator->createContainerTrackingVolume(
1198  lArCombinedVolumes, m_caloMaterial, "Calo::Containers::LAr::Combined");
1199 
1200  // glue with LAr sector
1201  Trk::TrackingVolume* caloCombined = nullptr;
1202  // ++ has 2 sub volumes in R
1203  std::vector<Trk::TrackingVolume*> caloVolumes;
1204  // ++++ (a) -> LAr sector
1205  caloVolumes.push_back(lArCombined);
1206  // ++++ (b) -> Tile sector
1207  caloVolumes.push_back(tileCombined);
1208  // ++++ all sub volumes exist: build the super volume
1209  caloCombined = m_trackingVolumeCreator->createContainerTrackingVolume(
1210  caloVolumes, m_caloMaterial, "Calo::Containers::CombinedCalo");
1211 
1213 
1214  // build the radial buffer volume to synchronize the radial envelope
1215  // dimensions
1216  Trk::TrackingVolume* centralBuffer = nullptr;
1217  Trk::TrackingVolume* ecPosBuffer = nullptr;
1218  Trk::TrackingVolume* ecNegBuffer = nullptr;
1219 
1220  if (caloVolsOuterRadius > caloDefaultRadius) {
1221  ATH_MSG_VERBOSE(
1222  "Calo volumes exceeds envelope radius: adjusting envelope "
1223  "(de-synchronizing...)");
1224  caloDefaultRadius = caloVolsOuterRadius;
1225  }
1226 
1227  if (caloVolsOuterRadius < caloDefaultRadius) {
1228  ATH_MSG_VERBOSE(
1229  "Build radial buffer to synchronize the boundaries in between R "
1230  << caloVolsOuterRadius << " and " << caloDefaultRadius);
1231 
1232  auto centralSynBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1233  caloVolsOuterRadius, caloDefaultRadius, caloVolsExtendZ);
1234  centralBuffer = new Trk::TrackingVolume(
1235  nullptr, std::move(centralSynBounds), m_caloMaterial, nullptr, nullptr,
1236  "Calo::GapVolumes::EnvelopeBuffer");
1237  }
1238 
1239  if (caloVolsExtendZ < caloDefaultHalflengthZ) {
1240  ATH_MSG_VERBOSE(
1241  "Build longitudinal buffers to synchronize the boundaries in between Z "
1242  << caloVolsExtendZ << " and " << caloDefaultHalflengthZ);
1243 
1244  auto endcapSynBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1245  0., caloDefaultRadius,
1246  0.5 * (caloDefaultHalflengthZ - caloVolsExtendZ));
1247  // endcap buffers not empty
1248  Trk::Material ecBuffMat(53. / 0.38, 355. / 0.38, 20., 10.,
1249  0.0053 * pow(0.38, 3));
1250 
1251  float zPos = 0.5 * (caloDefaultHalflengthZ + caloVolsExtendZ);
1252  ecPosBuffer = new Trk::TrackingVolume(
1253  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., zPos))),
1254  std::make_shared<Trk::CylinderVolumeBounds>(*endcapSynBounds),
1255  m_Ar, nullptr, nullptr,
1256  "Calo::GapVolumes::PosECBuffer");
1257 
1258  ecNegBuffer = new Trk::TrackingVolume(
1259  std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(0., 0., -zPos))),
1260  std::move(endcapSynBounds), m_Ar, nullptr, nullptr,
1261  "Calo::GapVolumes::NegECBuffer");
1262  }
1263 
1264  ATH_MSG_VERBOSE(
1265  "All gap volumes for the Calorimeter created. Starting to build Volume "
1266  "Hiearchy.");
1267 
1269 
1270  ATH_MSG_VERBOSE("Resolve MS cutouts:");
1271 
1272  // resolve number of additional cutout volumes
1273  int nCutVol = 0;
1274  std::vector<float> zCutStep;
1275  std::vector<float> rCutStep;
1276  if (msCutouts.size() > 1) {
1277  zCutStep.push_back(msCutouts[0].second);
1278  rCutStep.push_back(msCutouts[0].first);
1279  for (unsigned int i = 1; i < msCutouts.size(); i++) {
1280  if (msCutouts[i].second == zCutStep.back())
1281  rCutStep.push_back(msCutouts[i].first);
1282  else
1283  zCutStep.push_back(msCutouts[i].second);
1284  }
1285  nCutVol = zCutStep.size() - 1;
1286  }
1287  if (nCutVol > 0)
1288  ATH_MSG_VERBOSE(nCutVol << " MS cutout volume(s) required ");
1289 
1290  std::vector<Trk::TrackingVolume*> forwardCutoutVols;
1291  std::vector<Trk::TrackingVolume*> backwardCutoutVols;
1292 
1293  // cutout region not empty
1294  std::vector<Trk::Material> cutOutMat;
1295  cutOutMat.emplace_back(19.9, 213., 50., 23.,
1296  0.0065); // 3.5 Fe + 1 Ar : verify
1297  cutOutMat.push_back(m_caloMaterial);
1298  // cutOutMat.push_back(Trk::Material(18.74, 200.9, 52.36, 24.09, 0.0069));
1299 
1300  if (nCutVol > 0) {
1301  // loop over zCutStep, rCutStep[0] gives the fixed outer radius, rCutStep[i]
1302  // the cutout radius for ith volume
1303  float rout = rCutStep[0];
1304  float zlow = zCutStep[0];
1305  for (unsigned int i = 1; i < zCutStep.size(); i++) {
1306  float zup = zCutStep[i];
1307  float rcut = rCutStep[i];
1308  std::stringstream ss;
1309  ss << i;
1310  // get beam pipe volumes
1311  float rCutOutBP = 0.;
1312  std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> cutOutBP =
1313  createBeamPipeVolumes(bpCutouts, zlow, zup, "CutOuts" + ss.str(),
1314  rCutOutBP);
1315 
1316  // build inner part ( -> Calo )
1317  unsigned int mindex = i > 1 ? 1 : i;
1318 
1319  auto cutInBounds =
1320  std::make_shared<Trk::CylinderVolumeBounds>(rCutOutBP, rcut, 0.5 * (zup - zlow));
1321  Trk::TrackingVolume* caloInPos = new Trk::TrackingVolume(
1322  std::make_unique<Amg::Transform3D>(
1323  Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
1324  std::make_shared<Trk::CylinderVolumeBounds>(*cutInBounds),
1325  cutOutMat[mindex], nullptr, nullptr,
1326  "Calo::GapVolumes::CaloPositiveCutIn" + ss.str());
1327  Trk::TrackingVolume* caloInNeg = new Trk::TrackingVolume(
1328  std::make_unique<Amg::Transform3D>(
1329  Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
1330  std::move(cutInBounds),
1331  cutOutMat[mindex], nullptr, nullptr,
1332  "Calo::GapVolumes::CaloNegativeCutIn" + ss.str());
1333  // build cutout ( -> MS ) : geometry signature needs to be resolved later
1334  // : follow naming convention
1335  auto cutOutBounds = std::make_shared<Trk::CylinderVolumeBounds>(rcut, rout, 0.5 * (zup - zlow));
1336  Trk::TrackingVolume* caloOutPos = new Trk::TrackingVolume(
1337  std::make_unique<Amg::Transform3D>(
1338  Amg::Translation3D(Amg::Vector3D(0., 0., 0.5 * (zup + zlow)))),
1339  std::make_shared<Trk::CylinderVolumeBounds>(*cutOutBounds), m_caloMaterial, nullptr, nullptr,
1340  "Muon::GapVolumes::CaloPositiveCutOut" + ss.str());
1341  Trk::TrackingVolume* caloOutNeg = new Trk::TrackingVolume(
1342  std::make_unique<Amg::Transform3D>(
1343  Amg::Translation3D(Amg::Vector3D(0., 0., -0.5 * (zup + zlow)))),
1344  std::move(cutOutBounds),
1345  m_caloMaterial, nullptr, nullptr,
1346  "Muon::GapVolumes::CaloNegativeCutOut" + ss.str());
1347 
1348  // sign
1349  caloOutPos->sign(Trk::MS);
1350  caloOutNeg->sign(Trk::MS);
1351 
1352  // glue radially and save for final gluing
1353  std::vector<Trk::TrackingVolume*> cvPos;
1354  cvPos.push_back(cutOutBP.first);
1355  cvPos.push_back(caloInPos);
1356  cvPos.push_back(caloOutPos);
1357  Trk::TrackingVolume* cutOutPos =
1358  m_trackingVolumeCreator->createContainerTrackingVolume(
1359  cvPos, m_caloMaterial,
1360  "Calo::GapVolumes::CaloPositiveCutoutVolume" + ss.str());
1361  forwardCutoutVols.push_back(cutOutPos);
1362  //
1363  std::vector<Trk::TrackingVolume*> cvNeg;
1364  cvNeg.push_back(cutOutBP.second);
1365  cvNeg.push_back(caloInNeg);
1366  cvNeg.push_back(caloOutNeg);
1367  Trk::TrackingVolume* cutOutNeg =
1368  m_trackingVolumeCreator->createContainerTrackingVolume(
1369  cvNeg, m_caloMaterial,
1370  "Calo::GapVolumes::CaloNegativeCutoutVolume" + ss.str());
1371  backwardCutoutVols.insert(backwardCutoutVols.begin(), cutOutNeg);
1372 
1373  zlow = zup;
1374  }
1375  }
1376 
1378 
1379  if (!centralBuffer) { //(XX)
1380  // all volumes exist : create the super volume at top level
1381  calorimeter = caloCombined;
1382 
1383  } else { //(X)
1384 
1385  std::vector<Trk::TrackingVolume*> envRVols;
1386  envRVols.push_back(caloCombined);
1387  envRVols.push_back(centralBuffer);
1388 
1389  // add cutouts - final step
1390  if (!forwardCutoutVols.empty() || ecNegBuffer) {
1391 
1392  Trk::TrackingVolume* caloRVolume =
1393  m_trackingVolumeCreator->createContainerTrackingVolume(
1394  envRVols, m_caloMaterial, "Calo::Containers::CombinedRCalo");
1395  std::vector<Trk::TrackingVolume*> envZVols;
1396  envZVols.reserve(backwardCutoutVols.size());
1397  for (auto& backwardCutoutVol : backwardCutoutVols)
1398  envZVols.push_back(backwardCutoutVol);
1399  if (ecNegBuffer)
1400  envZVols.push_back(ecNegBuffer);
1401  envZVols.push_back(caloRVolume);
1402  if (ecPosBuffer)
1403  envZVols.push_back(ecPosBuffer);
1404  for (auto& forwardCutoutVol : forwardCutoutVols)
1405  envZVols.push_back(forwardCutoutVol);
1406 
1407  calorimeter = m_trackingVolumeCreator->createContainerTrackingVolume(
1408  envZVols, m_caloMaterial, m_exitVolume);
1409 
1410  } else { // if no cutouts or endcap buffers, this is the top calo volume
1411 
1412  calorimeter = m_trackingVolumeCreator->createContainerTrackingVolume(
1413  envRVols, m_caloMaterial, m_exitVolume);
1414  }
1415  }
1416 
1417  ATH_MSG_VERBOSE(
1418  "TrackingVolume 'Calorimeter' built successfully. Wrap it in "
1419  "TrackingGeometry.");
1420 
1421  auto caloTrackingGeometry = std::make_unique<Trk::TrackingGeometry>(calorimeter);
1422 
1423  if (msgLvl(MSG::VERBOSE) && caloTrackingGeometry){
1424  caloTrackingGeometry->printVolumeHierarchy(msg(MSG::VERBOSE));
1425  }
1426 
1427  if (m_indexStaticLayers && caloTrackingGeometry){
1428  caloTrackingGeometry->indexStaticLayers(signature());
1429  }
1430 
1431  return caloTrackingGeometry;
1432 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ geometrySignature()

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

The unique signature.

Implements Trk::IGeometryBuilder.

Definition at line 46 of file CaloTrackingGeometryBuilder.h.

46  {
47  return CaloTrackingGeometryBuilderImpl::signature();
48  }

◆ initialize()

StatusCode Calo::CaloTrackingGeometryBuilder::initialize ( )
overridevirtual

AlgTool initailize method.

Reimplemented from Calo::CaloTrackingGeometryBuilderImpl.

Definition at line 23 of file CaloTrackingGeometryBuilder.cxx.

23  {
24  return Calo::CaloTrackingGeometryBuilderImpl::initialize();
25 }

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

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ 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 1434 of file CaloTrackingGeometryBuilderImpl.cxx.

1437  {
1438 
1439  ATH_MSG_VERBOSE("[+] Registering layers of TrackingVolume '"
1440  << vol.volumeName() << "' in LayerIndex/CaloCell_ID map");
1441 
1442  // get the confined Layers from the TrackingVolume
1443  const Trk::LayerArray* confinedLayers = vol.confinedLayers();
1444  if (!confinedLayers)
1445  return;
1446 
1447  std::span<Trk::Layer const* const> layerObjects =
1448  confinedLayers->arrayObjects();
1449  std::span<Trk::Layer const* const>::iterator layerObjIter =
1450  layerObjects.begin();
1451  std::span<Trk::Layer const* const>::iterator layerObjEnd =
1452  layerObjects.end();
1453 
1454  // now pick out the material layers (and skip the navigation ones)
1455  std::vector<const Trk::Layer*> materialLayers;
1456  for (; layerObjIter != layerObjEnd; ++layerObjIter)
1457  if ((*layerObjIter)->layerMaterialProperties())
1458  materialLayers.push_back((*layerObjIter));
1459 
1460  unsigned int matLaySize = materialLayers.size();
1461  unsigned int ccidSize = ccid.size();
1462 
1463  ATH_MSG_VERBOSE("[+] Found " << matLaySize << " material layers ( "
1464  << ccidSize << " CaloSample ids )");
1465  if (matLaySize != ccidSize)
1466  return;
1467 
1468  // everything's fine for side > 0
1469  if (side > 0) {
1470  // match 1-to-1
1471  std::vector<const Trk::Layer*>::const_iterator layerIt = materialLayers.begin();
1472  std::vector<const Trk::Layer*>::const_iterator layerItEnd = materialLayers.end();
1473  std::vector<CaloCell_ID::CaloSample>::const_iterator ccidIt = ccid.begin();
1474  std::vector<CaloCell_ID::CaloSample>::const_iterator ccidItEnd = ccid.end();
1475 
1476  for (; layerIt != layerItEnd && ccidIt != ccidItEnd; ++layerIt, ++ccidIt)
1477  licsMap.insert(std::make_pair((*layerIt)->layerIndex(), int(*ccidIt)));
1478 
1479  } else {
1480  // the order needs to be reversed, because TG has z-ordering positive
1481  // defined
1482 
1483  std::vector<CaloCell_ID::CaloSample>::const_iterator ccidIt = ccid.begin();
1484  std::vector<CaloCell_ID::CaloSample>::const_iterator ccidItEnd = ccid.end();
1485 
1486  for (; ccidIt != ccidItEnd; ++ccidIt, --matLaySize)
1487  licsMap.insert(std::make_pair(
1488  (materialLayers[matLaySize - 1])->layerIndex(), int(*ccidIt)));
1489  }
1490 }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ signature()

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

The unique signature.

Definition at line 64 of file CaloTrackingGeometryBuilderImpl.h.

64  {
65  return Trk::Calo;
66  }

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

28  {
29 
30  std::unique_ptr<Trk::TrackingGeometry> trackingGeometry{};
31 
32  const CaloDetDescrManager* caloDDM =
33  detStore()->tryConstRetrieve<CaloDetDescrManager>(caloMgrStaticKey);
34  if (!caloDDM) {
35  std::unique_ptr<CaloDetDescrManager> caloMgrPtr =
36  buildCaloDetDescrNoAlign(serviceLocator(), Athena::getMessageSvc());
37  if (detStore()->record(std::move(caloMgrPtr), caloMgrStaticKey) !=
38  StatusCode::SUCCESS) {
39  ATH_MSG_WARNING("Failed to record CaloDetDescrManager with the key "
40  << caloMgrStaticKey << " in DetStore");
41  return trackingGeometry;
42  }
43  if (detStore()->retrieve(caloDDM, caloMgrStaticKey) !=
44  StatusCode::SUCCESS) {
45  ATH_MSG_WARNING("Failed to retrieve CaloDetDescrManager with the key "
46  << caloMgrStaticKey << " from DetStore");
47  return trackingGeometry;
48  }
49  }
50  // if caloDD is still null, we;re in trouble because it gets dereferenced
51  // after this
52  if (!caloDDM) {
53  ATH_MSG_WARNING("caloDDM is a null pointer in CaloTrackingGeometryBuilder");
54  return trackingGeometry;
55  }
56  return Calo::CaloTrackingGeometryBuilderImpl::createTrackingGeometry(innerVol,
57  caloDDM,
58  nullptr);
59 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_Al

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

Definition at line 86 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 85 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_buildMBTS

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

MBTS like detectors.

Definition at line 103 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 95 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 94 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 90 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_caloMaterial

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

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

Definition at line 88 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 92 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 111 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 112 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_indexStaticLayers

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

forces robust indexing for layers

Definition at line 98 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 79 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_layerIndexCaloSampleMapName

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

name to record it

Definition at line 101 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPhiGap

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

MBTS like detectors.

Definition at line 107 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPhiSegments

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

MBTS like detectors.

Definition at line 106 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPositionZ

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

MBTS like detectors.

Definition at line 108 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsRadiusGap

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

MBTS like detectors.

Definition at line 105 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsStaggeringZ

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

MBTS like detectors.

Definition at line 109 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_recordLayerIndexCaloSampleMap

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

for deposition methods

Definition at line 100 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 87 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_tileVolumeBuilder

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

Material properties.

Definition at line 81 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_trackingVolumeArrayCreator

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

Second helper for volume creation.

Definition at line 75 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 77 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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
Calo::CaloTrackingGeometryBuilderImpl::m_caloDefaultRadius
DoubleProperty m_caloDefaultRadius
the radius if not built from GeoModel
Definition: CaloTrackingGeometryBuilderImpl.h:94
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Calo::CaloTrackingGeometryBuilderImpl::m_caloDefaultHalflengthZ
DoubleProperty m_caloDefaultHalflengthZ
the halflength in z if not built from
Definition: CaloTrackingGeometryBuilderImpl.h:95
RZPairVector
std::vector< RZPair > RZPairVector
Definition: RZPair.h:18
Trk::binZ
@ binZ
Definition: BinningType.h:49
Calo::CaloTrackingGeometryBuilderImpl::m_enclosingEnvelopeSvc
ServiceHandle< IEnvelopeDefSvc > m_enclosingEnvelopeSvc
Definition: CaloTrackingGeometryBuilderImpl.h:92
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:169
Calo::CaloTrackingGeometryBuilderImpl::initialize
virtual StatusCode initialize() override
AlgTool initailize method.
Definition: CaloTrackingGeometryBuilderImpl.cxx:46
Calo::CaloTrackingGeometryBuilderImpl::createTrackingGeometry
std::unique_ptr< Trk::TrackingGeometry > createTrackingGeometry(Trk::TrackingVolume *innerVol, const CaloDetDescrManager *caloDDM, const GeoAlignmentStore *geoAlign) const
TrackingGeometry Interface method.
Definition: CaloTrackingGeometryBuilderImpl.cxx:75
Trk::BinnedMaterial
Definition: BinnedMaterial.h:31
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
Calo::CaloTrackingGeometryBuilderImpl::m_Ar
Trk::Material m_Ar
Definition: CaloTrackingGeometryBuilderImpl.h:85
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Calo::CaloTrackingGeometryBuilderImpl
Definition: CaloTrackingGeometryBuilderImpl.h:49
Trk::binEta
@ binEta
Definition: BinningType.h:54
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::Calo
@ Calo
Definition: GeometrySignature.h:28
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeCreator
PublicToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
Volume Builder for the Liquid Argon Calorimeter.
Definition: CaloTrackingGeometryBuilderImpl.h:77
Trk::BeamPipe
@ BeamPipe
Definition: GeometrySignature.h:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
Trk::MS
@ MS
Definition: GeometrySignature.h:29
Trk::TrackingVolume::confinedLayers
const LayerArray * confinedLayers() const
Return the subLayer array.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Calo::CaloTrackingGeometryBuilderImpl::m_caloMaterial
Trk::Material m_caloMaterial
Definition: CaloTrackingGeometryBuilderImpl.h:84
Calo::CaloTrackingGeometryBuilderImpl::m_indexStaticLayers
BooleanProperty m_indexStaticLayers
forces robust indexing for layers
Definition: CaloTrackingGeometryBuilderImpl.h:98
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
Calo::CaloTrackingGeometryBuilderImpl::m_crackMaterial
Trk::Material m_crackMaterial
Definition: CaloTrackingGeometryBuilderImpl.h:88
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
beamspotman.steps
int steps
Definition: beamspotman.py:501
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Calo::CaloTrackingGeometryBuilderImpl::signature
Trk::GeometrySignature signature() const
The unique signature.
Definition: CaloTrackingGeometryBuilderImpl.h:64
Calo::CaloTrackingGeometryBuilderImpl::createBeamPipeVolumes
std::pair< Trk::TrackingVolume *, Trk::TrackingVolume * > createBeamPipeVolumes(const RZPairVector &bpCutouts, float, float, const std::string &, float &) const
method to build enclosed beam pipe volumes
Definition: CaloTrackingGeometryBuilderImpl.cxx:1493
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
beamspotman.n
n
Definition: beamspotman.py:727
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:169
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:90
Trk::DiscLayer
Definition: DiscLayer.h:45
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::BinnedArray::arrayObjects
virtual std::span< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
Trk::BinUtility
Definition: BinUtility.h:39
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Calo::CaloTrackingGeometryBuilderImpl::m_buildMBTS
BooleanProperty m_buildMBTS
MBTS like detectors.
Definition: CaloTrackingGeometryBuilderImpl.h:103
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
Calo::CaloTrackingGeometryBuilderImpl::m_Scint
Trk::Material m_Scint
Definition: CaloTrackingGeometryBuilderImpl.h:87
Trk::Volume::transform
const Amg::Transform3D & transform() const
Return methods for geometry transform.
Definition: Volume.h:83
Calo::CaloTrackingGeometryBuilderImpl::m_exitVolume
StringProperty m_exitVolume
name of the Calo container
Definition: CaloTrackingGeometryBuilderImpl.h:112
Calo::CaloTrackingGeometryBuilder::trackingGeometry
virtual std::unique_ptr< Trk::TrackingGeometry > trackingGeometry(Trk::TrackingVolume *tvol=0) const override
TrackingGeometry Interface methode.
Definition: CaloTrackingGeometryBuilder.cxx:27
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
CaloDetDescrManager_Base::is_in
bool is_in(double eta, double phi, CaloCell_ID::CaloSample sample, double &etadist) const
return true if direction eta,phi crosses ANY of the corresponding descriptors
Definition: CaloDetDescrManager.cxx:1348
Trk::open
@ open
Definition: BinningType.h:40
Calo::CaloTrackingGeometryBuilderImpl::m_Al
Trk::Material m_Al
Definition: CaloTrackingGeometryBuilderImpl.h:86
Trk::MaterialProperties
Definition: MaterialProperties.h:40
a
TList * a
Definition: liststreamerinfos.cxx:10
h
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
Trk::CylinderVolumeBounds::innerRadius
double innerRadius() const
This method returns the inner radius.
Definition: CylinderVolumeBounds.h:187
Trk::TrackingVolume::sign
void sign(GeometrySignature signat, GeometryType gtype=Static)
sign the volume - the geometry builder has to do that
Definition: TrackingVolume.cxx:766
DeMoScan.first
bool first
Definition: DeMoScan.py:534
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
Calo::CaloTrackingGeometryBuilderImpl::m_lArVolumeBuilder
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder > m_lArVolumeBuilder
Volume Builder for the Tile Calorimeter.
Definition: CaloTrackingGeometryBuilderImpl.h:79
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:96
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
Trk::Material
Definition: Material.h:117
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
Trk::BinnedArray
Definition: BinnedArray.h:36
Trk::HomogeneousLayerMaterial
Definition: HomogeneousLayerMaterial.h:53
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Trk::TrackingVolume
Definition: TrackingVolume.h:119
Material
@ Material
Definition: MaterialTypes.h:8
Calo::CaloTrackingGeometryBuilderImpl::m_tileVolumeBuilder
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder > m_tileVolumeBuilder
Material properties.
Definition: CaloTrackingGeometryBuilderImpl.h:81
buildCaloDetDescrNoAlign
std::unique_ptr< CaloDetDescrManager > buildCaloDetDescrNoAlign(ISvcLocator *svcLocator, IMessageSvc *msgSvc)
Definition: CaloDetDescrBuilder.cxx:791
fitman.k
k
Definition: fitman.py:528
Trk::TrackingVolume::screenDump
void screenDump(MsgStream &msg) const
Definition: TrackingVolume.cxx:1185
Trk::AlignableTrackingVolume
Definition: AlignableTrackingVolume.h:36
Generated on Sat Sep 27 2025 22:02:07 for ATLAS Offline Software by   doxygen 1.8.18