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

#include <CaloTrackingGeometryBuilderImpl.h>

Inheritance diagram for Calo::CaloTrackingGeometryBuilderImpl:
Collaboration diagram for Calo::CaloTrackingGeometryBuilderImpl:

Public Member Functions

virtual ~CaloTrackingGeometryBuilderImpl ()
 Destructor. More...
 
virtual StatusCode initialize () override
 AlgTool initailize method. More...
 
std::unique_ptr< Trk::TrackingGeometry > createTrackingGeometry (Trk::TrackingVolume *innerVol, const CaloDetDescrManager *caloDDM) const
 TrackingGeometry Interface method. More...
 
Trk::GeometrySignature signature () const
 The unique signature. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

 CaloTrackingGeometryBuilderImpl (const std::string &, const std::string &, const IInterface *)
 Constructor. More...
 
void registerInLayerIndexCaloSampleMap (Trk::LayerIndexSampleMap &licsMAp, std::vector< CaloCell_ID::CaloSample > ccid, const Trk::TrackingVolume &vol, int side=1) const
 method to establish a link between the LayerIndex and the CaloCell_ID in an associative container More...
 
std::pair< Trk::TrackingVolume *, Trk::TrackingVolume * > createBeamPipeVolumes (const RZPairVector &bpCutouts, float, float, const std::string &, float &) const
 method to build enclosed beam pipe volumes More...
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

PublicToolHandle< Trk::ITrackingVolumeArrayCreator > m_trackingVolumeArrayCreator {this, "TrackingVolumeArrayCreator", "Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"}
 Helper Tool to create TrackingVolumes. More...
 
PublicToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper {this, "TrackingVolumeHelper", "Trk::TrackingVolumeHelper/TrackingVolumeHelper"}
 Second helper for volume creation. More...
 
PublicToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator {this, "TrackingVolumeCreator", "Trk::CylinderVolumeCreator/TrackingVolumeCreator"}
 Volume Builder for the Liquid Argon Calorimeter. More...
 
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder > m_lArVolumeBuilder {this, "LArVolumeBuilder", "LAr::LArVolumeBuilder/LArVolumeBuilder"}
 Volume Builder for the Tile Calorimeter. More...
 
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder > m_tileVolumeBuilder {this, "TileVolumeBuilder", "Tile::TileVolumeBuilder/TileVolumeBuilder"}
 Material properties. More...
 
Trk::Material m_caloMaterial {}
 
Trk::Material m_Ar {140.036, 856.32, 39.948, 18., 0.0014}
 
Trk::Material m_Al {88.93, 388.62, 26.98, 13., 0.0027}
 
Trk::Material m_Scint {424.35, 707.43, 11.16, 5.61, 0.001}
 
Trk::Material m_crackMaterial {424.35, 707.43, 11.16, 5.61, 0.001}
 
DoubleProperty m_caloEnvelope {this, "GapLayerEnvelope", 25 * Gaudi::Units::mm}
 Envelope cover for Gap Layers. More...
 
ServiceHandle< IEnvelopeDefSvc > m_enclosingEnvelopeSvc {this, "EnvelopeDefinitionSvc", "AtlasGeometry_EnvelopeDefSvc"}
 
DoubleProperty m_caloDefaultRadius {this, "CalorimeterRadius", 4250.}
 the radius if not built from GeoModel More...
 
DoubleProperty m_caloDefaultHalflengthZ {this, "CalorimeterHalflengthZ", 6500.}
 the halflength in z if not built from More...
 
BooleanProperty m_indexStaticLayers {this, "IndexStaticLayers", true}
 forces robust indexing for layers More...
 
BooleanProperty m_recordLayerIndexCaloSampleMap {this, "RecordLayerIndexCaloSampleMap", true}
 for deposition methods More...
 
StringProperty m_layerIndexCaloSampleMapName {this, "LayerIndexCaloSampleMapName", "LayerIndexCaloSampleMap"}
 name to record it More...
 
BooleanProperty m_buildMBTS {this, "BuildMBTS", true}
 MBTS like detectors. More...
 
std::vector< double > m_mbtsRadiusGap
 MBTS like detectors. More...
 
std::vector< int > m_mbtsPhiSegments
 MBTS like detectors. More...
 
std::vector< double > m_mbtsPhiGap
 MBTS like detectors. More...
 
std::vector< double > m_mbtsPositionZ
 MBTS like detectors. More...
 
std::vector< double > m_mbtsStaggeringZ
 MBTS like detectors. More...
 
StringProperty m_entryVolume {this, "EntryVolumeName", "Calo::Container::EntryVolume"}
 name of the Calo entrance More...
 
StringProperty m_exitVolume {this, "ExitVolumeName", "Calo::Container"}
 name of the Calo container More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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

Detailed Description

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

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

Definition at line 50 of file CaloTrackingGeometryBuilderImpl.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~CaloTrackingGeometryBuilderImpl()

Calo::CaloTrackingGeometryBuilderImpl::~CaloTrackingGeometryBuilderImpl ( )
virtualdefault

Destructor.

◆ CaloTrackingGeometryBuilderImpl()

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

Constructor.

Helper Tool to create TrackingVolume Arrays

Definition at line 37 of file CaloTrackingGeometryBuilderImpl.cxx.

39  : AthAlgTool(t, n, p) {
40 }

Member Function Documentation

◆ createBeamPipeVolumes()

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

method to build enclosed beam pipe volumes

Definition at line 1478 of file CaloTrackingGeometryBuilderImpl.cxx.

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

◆ createTrackingGeometry()

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

TrackingGeometry Interface method.

Definition at line 96 of file CaloTrackingGeometryBuilderImpl.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

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

◆ initialize()

StatusCode Calo::CaloTrackingGeometryBuilderImpl::initialize ( )
overridevirtual

AlgTool initailize method.

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

Definition at line 47 of file CaloTrackingGeometryBuilderImpl.cxx.

47  {
48 
49  // Retrieve the tracking volume array creator
50  // -------------------------------------------------
51  if (m_trackingVolumeArrayCreator.retrieve().isFailure()) {
52  ATH_MSG_FATAL("Failed to retrieve tool " << m_trackingVolumeArrayCreator);
53  return StatusCode::FAILURE;
54  } else
55  ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeArrayCreator);
56 
57  // Retrieve the tracking volume helper
58  // -------------------------------------------------
59  if (m_trackingVolumeHelper.retrieve().isFailure()) {
60  ATH_MSG_FATAL("Failed to retrieve tool " << m_trackingVolumeHelper);
61  return StatusCode::FAILURE;
62  } else
63  ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeHelper);
64 
65  // Retrieve the second volume creator
66  if (m_buildMBTS && m_trackingVolumeCreator.retrieve().isFailure()) {
67  ATH_MSG_FATAL("Failed to retrieve tool " << m_trackingVolumeCreator);
68  return StatusCode::FAILURE;
69  } else
70  ATH_MSG_INFO("Retrieved tool " << m_trackingVolumeCreator);
71 
72  // Retrieve the volume builders
73 
74  // Retrieve the tracking volume array creator
75  // -------------------------------------------------
76  if (m_lArVolumeBuilder.retrieve().isFailure()) {
77  ATH_MSG_FATAL("Failed to retrieve tool " << m_lArVolumeBuilder);
78  return StatusCode::FAILURE;
79  } else
80  ATH_MSG_INFO("Retrieved tool " << m_lArVolumeBuilder);
81 
82  // Retrieve the tracking volume helper
83  // -------------------------------------------------
84  if (m_tileVolumeBuilder.retrieve().isFailure()) {
85  ATH_MSG_FATAL("Failed to retrieve tool " << m_tileVolumeBuilder);
86  return StatusCode::FAILURE;
87  } else
88  ATH_MSG_INFO("Retrieved tool " << m_tileVolumeBuilder);
89 
90  ATH_MSG_INFO("initialize() succesful");
91 
92  return StatusCode::SUCCESS;
93 }

◆ 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,
std::vector< CaloCell_ID::CaloSample >  ccid,
const Trk::TrackingVolume &  vol,
int  side = 1 
) const
protected

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

Definition at line 1419 of file CaloTrackingGeometryBuilderImpl.cxx.

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

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

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.

◆ 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}
protected

Definition at line 88 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_Ar

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

Definition at line 87 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_buildMBTS

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

MBTS like detectors.

Definition at line 105 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_caloDefaultHalflengthZ

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

the halflength in z if not built from

GeoModel

Definition at line 97 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_caloDefaultRadius

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

the radius if not built from GeoModel

Definition at line 96 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_caloEnvelope

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

Envelope cover for Gap Layers.

Definition at line 92 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_caloMaterial

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

Definition at line 86 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_crackMaterial

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

Definition at line 90 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"}
protected

Definition at line 94 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_entryVolume

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

name of the Calo entrance

Definition at line 113 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"}
protected

name of the Calo container

Definition at line 114 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_indexStaticLayers

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

forces robust indexing for layers

Definition at line 100 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_lArVolumeBuilder

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

Volume Builder for the Tile Calorimeter.

Definition at line 81 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_layerIndexCaloSampleMapName

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

name to record it

Definition at line 103 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPhiGap

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

MBTS like detectors.

Definition at line 109 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPhiSegments

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

MBTS like detectors.

Definition at line 108 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsPositionZ

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

MBTS like detectors.

Definition at line 110 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsRadiusGap

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

MBTS like detectors.

Definition at line 107 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_mbtsStaggeringZ

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

MBTS like detectors.

Definition at line 111 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_recordLayerIndexCaloSampleMap

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

for deposition methods

Definition at line 102 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_Scint

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

Definition at line 89 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_tileVolumeBuilder

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

Material properties.

Definition at line 83 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_trackingVolumeArrayCreator

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

Helper Tool to create TrackingVolumes.

Definition at line 75 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_trackingVolumeCreator

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

Volume Builder for the Liquid Argon Calorimeter.

Definition at line 79 of file CaloTrackingGeometryBuilderImpl.h.

◆ m_trackingVolumeHelper

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

Second helper for volume creation.

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:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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:96
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:97
python.App.bins
bins
Definition: App.py:410
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:94
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:176
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
Trk::BinnedMaterial
Definition: BinnedMaterial.h:38
Calo::CaloTrackingGeometryBuilderImpl::m_Ar
Trk::Material m_Ar
Definition: CaloTrackingGeometryBuilderImpl.h:87
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
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
Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeCreator
PublicToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
Volume Builder for the Liquid Argon Calorimeter.
Definition: CaloTrackingGeometryBuilderImpl.h:79
Trk::BinUtility::bins
size_t bins(size_t ba=0) const
Number of bins.
Definition: BinUtility.h:223
Trk::BeamPipe
@ BeamPipe
Definition: GeometrySignature.h:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
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.
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
Calo::CaloTrackingGeometryBuilderImpl::m_caloMaterial
Trk::Material m_caloMaterial
Definition: CaloTrackingGeometryBuilderImpl.h:86
Calo::CaloTrackingGeometryBuilderImpl::m_indexStaticLayers
BooleanProperty m_indexStaticLayers
forces robust indexing for layers
Definition: CaloTrackingGeometryBuilderImpl.h:100
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
Calo::CaloTrackingGeometryBuilderImpl::m_crackMaterial
Trk::Material m_crackMaterial
Definition: CaloTrackingGeometryBuilderImpl.h:90
beamspotman.steps
int steps
Definition: beamspotman.py:505
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Trk::DiscBounds::clone
virtual DiscBounds * clone() const override final
Virtual constructor.
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:1478
lumiFormat.i
int i
Definition: lumiFormat.py:92
z
#define z
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
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:176
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:86
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
Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeArrayCreator
PublicToolHandle< Trk::ITrackingVolumeArrayCreator > m_trackingVolumeArrayCreator
Helper Tool to create TrackingVolumes.
Definition: CaloTrackingGeometryBuilderImpl.h:75
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
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.
Calo::CaloTrackingGeometryBuilderImpl::m_trackingVolumeHelper
PublicToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
Second helper for volume creation.
Definition: CaloTrackingGeometryBuilderImpl.h:77
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Calo::CaloTrackingGeometryBuilderImpl::m_buildMBTS
BooleanProperty m_buildMBTS
MBTS like detectors.
Definition: CaloTrackingGeometryBuilderImpl.h:105
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
Trk::BinnedArray::arrayObjects
virtual BinnedArraySpan< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
Calo::CaloTrackingGeometryBuilderImpl::m_Scint
Trk::Material m_Scint
Definition: CaloTrackingGeometryBuilderImpl.h:89
Trk::Volume::transform
const Amg::Transform3D & transform() const
Return methods for geometry transform.
Definition: Volume.h:81
Calo::CaloTrackingGeometryBuilderImpl::m_exitVolume
StringProperty m_exitVolume
name of the Calo container
Definition: CaloTrackingGeometryBuilderImpl.h:114
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
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
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
Calo::CaloTrackingGeometryBuilderImpl::m_Al
Trk::Material m_Al
Definition: CaloTrackingGeometryBuilderImpl.h:88
Trk::MaterialProperties
Definition: MaterialProperties.h:40
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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:941
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:81
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:97
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
Trk::Material
Definition: Material.h:116
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
Trk::BinnedArray
Definition: BinnedArray.h:38
Trk::HomogeneousLayerMaterial
Definition: HomogeneousLayerMaterial.h:53
Trk::TrackingVolume
Definition: TrackingVolume.h:121
Trk::CylinderVolumeBounds::clone
CylinderVolumeBounds * clone() const override
Virtual constructor.
Definition: CylinderVolumeBounds.h:171
Material
@ Material
Definition: MaterialTypes.h:8
Calo::CaloTrackingGeometryBuilderImpl::m_tileVolumeBuilder
PublicToolHandle< Trk::ICaloTrackingVolumeBuilder > m_tileVolumeBuilder
Material properties.
Definition: CaloTrackingGeometryBuilderImpl.h:83
Trk::BinnedArraySpan
std::span< T > BinnedArraySpan
Definition: BinnedArray.h:34
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
fitman.k
k
Definition: fitman.py:528
Trk::DiscBounds
Definition: DiscBounds.h:44
Trk::TrackingVolume::screenDump
void screenDump(MsgStream &msg) const
Definition: TrackingVolume.cxx:1506
Trk::AlignableTrackingVolume
Definition: AlignableTrackingVolume.h:36
Generated on Fri Jun 28 2024 22:13:17 for ATLAS Offline Software by   doxygen 1.8.18