Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TileVolumeBuilder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // TileVolumeBuilder.cxx, (c) ATLAS Detector software
8 
9 // Tile
10 #include "TileTrackingGeometry/TileVolumeBuilder.h"
11 // Tile
12 #include "TileDetDescr/TileDetDescrManager.h"
13 // Calo
14 #include "CaloDetDescr/CaloDepthTool.h"
15 #include "CaloDetDescr/CaloDetDescrManager.h"
16 #include "CaloDetDescr/CaloDetDescriptor.h"
17 #include "CaloDetDescr/CaloDetDescrElement.h"
18 // GeoModel
19 #include "GeoModelKernel/GeoFullPhysVol.h"
20 #include "GeoModelKernel/GeoLogVol.h"
21 #include "GeoModelKernel/GeoShape.h"
22 #include "GeoModelKernel/GeoTubs.h"
23 #include "GeoModelKernel/GeoTube.h"
24 #include "GeoModelKernel/GeoPcon.h"
25 #include "GeoModelKernel/GeoTrd.h"
26 #include "GeoModelKernel/GeoMaterial.h"
27 #include "GeoModelKernel/GeoVPhysVol.h"
28 #include "GeoModelKernel/GeoVolumeCursor.h"
29 #include "GeoModelKernel/Units.h"
30 // Trk
31 #include "TrkDetDescrInterfaces/ITrackingVolumeHelper.h"
32 #include "TrkDetDescrInterfaces/ITrackingVolumeCreator.h"
33 //#include "TrkDetDescrInterfaces/IMaterialEffectsOnTrackProvider.h"
34 #include "TrkDetDescrUtils/GeometryStatics.h"
35 #include "TrkDetDescrUtils/BinnedArray.h"
36 #include "TrkDetDescrUtils/BinningType.h"
37 #include "TrkGeometry/TrackingVolume.h"
38 #include "TrkGeometry/AlignableTrackingVolume.h"
39 #include "TrkGeometry/Material.h"
40 #include "TrkGeometry/CylinderLayer.h"
41 #include "TrkGeometry/DiscLayer.h"
42 #include "TrkGeometry/LayerMaterialProperties.h"
43 #include "TrkDetDescrGeoModelCnv/GeoShapeConverter.h"
44 #include "TrkDetDescrGeoModelCnv/GeoMaterialConverter.h"
45 #include "TrkVolumes/CylinderVolumeBounds.h"
46 #include "TrkSurfaces/CylinderSurface.h"
47 #include "TrkSurfaces/CylinderBounds.h"
48 #include "TrkSurfaces/DiscSurface.h"
49 #include "TrkSurfaces/DiscBounds.h"
50 // Gaudi
51 #include "GaudiKernel/MsgStream.h"
52 #include "GaudiKernel/SystemOfUnits.h"
53 // StoreGate
54 #include "StoreGate/StoreGateSvc.h"
55 
56 using Gaudi::Units::mm;
57 using std::make_unique;
58 
59 // constructor
60 Tile::TileVolumeBuilder::TileVolumeBuilder(const std::string& t, const std::string& n, const IInterface* p) :
61  AthAlgTool(t,n,p),
62  m_tileMgr(nullptr),
63  m_tileMgrLocation("Tile"),
64  m_trackingVolumeHelper("Trk::TrackingVolumeHelper/TrackingVolumeHelper"),
65  m_trackingVolumeCreator("Trk::CylinderVolumeCreator/TrackingVolumeCreator"),
66  m_tileBarrelEnvelope(25.*mm),
67  m_useCaloSurfBuilder(true),
68  m_tileBarrelLayersPerSampling(1),
69  m_surfBuilder("CaloSurfaceBuilder"),
70  m_forceSymmetry(true)
71 
72 {
73  declareInterface<Trk::ICaloTrackingVolumeBuilder>(this);
74  // declare the properties via Python
75  declareProperty("TileDetManagerLocation", m_tileMgrLocation);
76  // layers and general setup
77  declareProperty("BarrelEnvelopeCover", m_tileBarrelEnvelope);
78  declareProperty("ForceVolumeSymmetry", m_forceSymmetry);
79  // helper tools
80  declareProperty("TrackingVolumeHelper", m_trackingVolumeHelper);
81  declareProperty("TrackingVolumeCreator", m_trackingVolumeCreator);
82  declareProperty("UseCaloSurfBuilder", m_useCaloSurfBuilder);
83  declareProperty("BarrelLayersPerSampling", m_tileBarrelLayersPerSampling);
84  declareProperty("CaloSurfaceBuilder", m_surfBuilder);
85 }
86 
87 // destructor
88 Tile::TileVolumeBuilder::~ TileVolumeBuilder()
89 = default;
90 
91 
92 // Athena standard methods
93 // initialize
94 StatusCode Tile::TileVolumeBuilder::initialize()
95 {
96  // get Tile Detector Description Manager
97  if (detStore()->retrieve(m_tileMgr, m_tileMgrLocation).isFailure()){
98  ATH_MSG_FATAL( "Could not get TileDetDescrManager! Tile TrackingVolumes will not be built" );
99  return StatusCode::FAILURE;
100  }
101 
102  // Retrieve the tracking volume helper -------------------------------------------------
103  if (m_trackingVolumeHelper.retrieve().isFailure())
104  {
105  ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeHelper );
106  return StatusCode::FAILURE;
107  } else
108  ATH_MSG_INFO( "Retrieved tool " << m_trackingVolumeHelper );
109 
110  // Retrieve the second volume creator
111  if (m_trackingVolumeCreator.retrieve().isFailure()){
112  ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackingVolumeCreator );
113  return StatusCode::FAILURE;
114  } else
115  ATH_MSG_INFO( "Retrieved tool " << m_trackingVolumeCreator );
116 
117  if(m_surfBuilder.retrieve().isFailure())
118  {
119  ATH_MSG_FATAL( "Failed to retrieve tool " << m_surfBuilder );
120  return StatusCode::FAILURE;
121  } else
122  ATH_MSG_INFO( "Retrieved tool " << m_surfBuilder );
123 
124  ATH_MSG_INFO( " initialize() successful" );
125  return StatusCode::SUCCESS;
126 }
127 
128 std::vector<Trk::TrackingVolume*> Tile::TileVolumeBuilder::trackingVolumes(
129  const CaloDetDescrManager& caloDDM,
130  const GeoAlignmentStore* /*geoAlign*/) const {
131  // the return vector
132  auto tileTrackingVolumes = std::vector<Trk::TrackingVolume*>();
133  // the converter helpers
134  //Trk::GeoShapeConverter geoShapeToVolumeBounds;
135  //Trk::GeoMaterialConverter geoMaterialToMaterialProperties;
136  // dummy material
137  Trk::Material tileMaterial;
138 
139  // dimensions
140  double tileZ = 0.;
141  double gapZ = 0.;
142  // ITC hardcoded : simple shortcut (needs resizing anyway )
143  double plug1Z = 3405.;
144  double plug2Z = 3512.075;
145  double plug1R = 3440.;
146  double plug2R = 2959.;
147  double plug1hZ = 154.5;
148  double plug2hZ = 47.425;
149 
150  // The Volumes To be Created ( by parsing geoModel ) ===========
151  Trk::TrackingVolume* tileBarrel = nullptr;
152  Trk::TrackingVolume* tileGirder = nullptr;
153 
154  Trk::TrackingVolume* tilePositiveExtendedBarrel = nullptr;
155  Trk::TrackingVolume* tileNegativeExtendedBarrel = nullptr;
156 
157  // The Volumes To be Created ( Gap Volumes ) ====================
158  Trk::TrackingVolume* tileBarrelPositiveFingerGap = nullptr;
159  Trk::TrackingVolume* tileBarrelNegativeFingerGap = nullptr;
160  Trk::TrackingVolume* tilePositiveFingerGap = nullptr;
161  Trk::TrackingVolume* tileNegativeFingerGap = nullptr;
162 
163  // The Bounds To be Assigned (for resizing) ====================
164  std::shared_ptr<Trk::CylinderVolumeBounds> tileBarrelBounds;
165  std::unique_ptr<Trk::CylinderVolumeBounds> tileBarrelGirderBounds;
166 
167  Trk::CylinderVolumeBounds tilePositiveExtendedBarrelBounds;
168  std::shared_ptr<Trk::CylinderVolumeBounds> itcPlug1Bounds;
169  std::shared_ptr<Trk::CylinderVolumeBounds> itcPlug2Bounds;
170  std::shared_ptr<Trk::CylinderVolumeBounds> gapBounds;
171 
172  // dummy objects
173  Trk::LayerArray* dummyLayers = nullptr;
174  Trk::TrackingVolumeArray* dummyVolumes = nullptr;
175 
176  std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> entrySurf =
177  m_surfBuilder->entrySurfaces(&caloDDM);
178  std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> exitSurf =
179  m_surfBuilder->exitSurfaces(&caloDDM);
180 
181  // averaged material properties
182  auto barrelProperties = std::make_shared<Trk::Material>(22.7, 212., 45.8, 21.4, 0.0062);
183  auto extendedBarrelProperties = std::make_shared<Trk::Material>(22.7, 210., 45.8, 21.4, 0.0062);
184  // material properties with layer encoding - to be defined later
185  Trk::BinnedMaterial barrelMaterialBinned{};
186  Trk::BinnedMaterial extendedMaterialBinned{};
187 
188  Trk::Material girderProperties = Trk::Material(28.6, 272.5, 40.4, 19., 0.0049);
189  Trk::Material extendedGirderProperties = Trk::Material(27.9, 266.4, 41., 19.2, 0.005);
190  Trk::Material fingerProperties = Trk::Material(46., 426.6, 34.2, 16.2, 0.0032);
191 
192  unsigned int numTreeTops = m_tileMgr->getNumTreeTops();
193  ATH_MSG_DEBUG( "Retrieved " << numTreeTops << " tree tops from the TileDetDescrManager. " );
194 
195  // layer material can be adjusted here
196  std::vector<Trk::IdentifiedMaterial> matTB;
197  int baseID = Trk::GeometrySignature(Trk::Calo)*1000 + 12;
198  matTB.emplace_back(barrelProperties,0);
199  matTB.emplace_back(barrelProperties,baseID);
200  matTB.emplace_back(barrelProperties,baseID+1);
201  matTB.emplace_back(barrelProperties,baseID+2);
202 
203  // material index
204  std::vector<size_t> ltb{0,1,2,3};
205 
206  // layer material can be adjusted here
207  std::vector<Trk::IdentifiedMaterial> matETB;
208  baseID = Trk::GeometrySignature(Trk::Calo)*1000 + 18;
209  matETB.emplace_back(extendedBarrelProperties,0);
210  matETB.emplace_back(extendedBarrelProperties,baseID);
211  matETB.emplace_back(extendedBarrelProperties,baseID+1);
212  matETB.emplace_back(extendedBarrelProperties,baseID+2);
213 
214  // layer material can be adjusted here
215  //Trk::MaterialProperties barrelFingerGapProperties = Trk::MaterialProperties(1., 130./0.35, 0.003*pow(0.35,3),30.);
216  Trk::Material barrelFingerGapProperties(353., 2254., 20.7, 10., 0.00057);
217 
218  //Trk::MaterialProperties fingerGapProperties = Trk::MaterialProperties(1., 88./0.1, 0.003*pow(0.1,3),30.);
219  Trk::Material fingerGapProperties(552., 3925., 16.4, 8.1, 0.00034);
220 
221  for (unsigned int itreetop = 0; itreetop<numTreeTops; ++itreetop){
222  PVConstLink currentVPhysVolLink = m_tileMgr->getTreeTop(itreetop);
223 
224  // const GeoVPhysVol* top = &(*(m_tileMgr->getTreeTop(itreetop)));
225  //GeoVolumeCursor vol (top);
226  //while (!vol.atEnd()) {
227  // const GeoVPhysVol* cv = &(*(vol.getVolume()));
228  // printInfo(cv);
229  //}
230 
231  const GeoLogVol* currentLogVol = currentVPhysVolLink->getLogVol();
232 
233  unsigned int currentChilds = currentVPhysVolLink->getNChildVols();
234 
235  ATH_MSG_DEBUG( "Processing " << currentLogVol->getName() << "... has "
236  << currentChilds << " childs." );
237  const GeoShape* currentShape = currentLogVol->getShape();
238  ATH_MSG_VERBOSE( " -> the shape is " << currentShape->type() );
239  std::vector<double> zboundaries;
240 
241  ATH_MSG_DEBUG( "Start looping over childs. " );
242  // the loop over the childs
243  for (unsigned int ichild = 0; ichild < currentChilds; ++ichild){
244 
245  PVConstLink currentChildLink = currentVPhysVolLink->getChildVol(ichild);
246  //printInfo(currentChildLink);
247  const GeoLogVol* childLogVol = currentChildLink->getLogVol();
248  const GeoShape* childShape = childLogVol->getShape();
249  ATH_MSG_VERBOSE( " Child: " << childLogVol->getName() << " has shape " << childShape->type() );
250 
251  const GeoTubs* currentTubs = dynamic_cast<const GeoTubs*>(childShape);
252  std::shared_ptr<Trk::CylinderVolumeBounds> childCylVolBounds = currentTubs ? Trk::GeoShapeConverter::convert(currentTubs) : nullptr;
253  // get the transform
254  GeoTrf::Transform3D childTransform = currentVPhysVolLink->getXToChildVol(ichild);
255  double childZposition = childTransform.translation().z();
256 
257  if (childCylVolBounds){
258  // screen output
259  ATH_MSG_VERBOSE( " ---> CylinderVolumeBounds created as: " );
260  ATH_MSG_VERBOSE( " ---> Position in z: " << childTransform.translation().z() );
261  ATH_MSG_VERBOSE( *childCylVolBounds );
262 
263  // retrieve split radius from the TileBar2 exit surface
264  double depth = exitSurf[CaloCell_ID::TileBar2].first->bounds().r();
265 
266  switch (itreetop){
267 
268  case 0 : { // Tile Barrel case ==================================================================
269 
270  // the centered one is the TileBarrel
271  if ( fabs(childZposition)< 100.*mm ){
272  //depth is where we split childCylVolBounds
273  tileBarrelBounds = std::make_shared<Trk::CylinderVolumeBounds>(childCylVolBounds->innerRadius(),depth,childCylVolBounds->halflengthZ());
274 
275  // assign Bounds
276  tileBarrelGirderBounds = make_unique<Trk::CylinderVolumeBounds>(depth,childCylVolBounds->outerRadius(),childCylVolBounds->halflengthZ());
277 
278  // construct bin utilities
279  std::vector<float> steps;
280  steps.push_back(childCylVolBounds->innerRadius());
281  steps.push_back(entrySurf[CaloCell_ID::TileBar0].first->bounds().r());
282  steps.push_back(entrySurf[CaloCell_ID::TileBar1].first->bounds().r());
283  steps.push_back(entrySurf[CaloCell_ID::TileBar2].first->bounds().r());
284  steps.push_back(depth);
285  auto rBU = Trk::BinUtility(steps, Trk::open, Trk::binR);
286 
287  barrelMaterialBinned = Trk::BinnedMaterial(*barrelProperties,rBU,ltb,matTB);
288 
289  tileBarrel = new Trk::AlignableTrackingVolume(
290  nullptr, tileBarrelBounds, barrelMaterialBinned, 12,
291  "Calo::Detectors::Tile::Barrel");
292  }
293  } break;
294 
295  default : { // Tile Extended Barrel ==================================================================
296 
297  std::string volumeName;
298  std::string girderName;
299  std::vector<double> girderLayerRadius;
300  std::vector<double> layerRadius;
301  std::vector<double> layerEnvelope;
302  std::shared_ptr<Trk::CylinderVolumeBounds> tileExtendedBounds = nullptr;
303  std::unique_ptr<Trk::CylinderVolumeBounds> gapVolBounds;
304 
305  // prepare for the Extended Barrel
306  if (childCylVolBounds->halflengthZ() > 1000.){
307  volumeName = childZposition > 0. ?
308  "Calo::Detectors::Tile::PositiveExtendedBarrel" : "Calo::Detectors::Tile::NegativeExtendedBarrel";
309 
310  //depth is where we split childCylVolBounds
311  tileExtendedBounds = std::make_shared<Trk::CylinderVolumeBounds>(childCylVolBounds->innerRadius(),depth,childCylVolBounds->halflengthZ());
312 
313  } else if (childCylVolBounds->halflengthZ() > 100.){
314  // prepare for the EBarrel Finger : (ST) : merge with combined girder
315  //tileFingerBounds = new Trk::CylinderVolumeBounds(depth,childCylVolBounds->outerRadius(),childCylVolBounds->halflengthZ());
316 
317  } else if ( childLogVol->getName()=="Gap" && !gapBounds ) {
318 
319  gapVolBounds = make_unique<Trk::CylinderVolumeBounds>(childCylVolBounds->innerRadius(),childCylVolBounds->outerRadius(),
320  childCylVolBounds->halflengthZ());
321 
322  gapZ = fabs(childZposition);
323 
324  } else {
325  ATH_MSG_VERBOSE( " ---> This Volume is not gonna built !" );
326  break;
327  }
328 
329  // only account for misalignment along z
330  Amg::Vector3D childPosition(0.,0.,childZposition);
331  Trk::TrackingVolume* tileExtendedTrackingVolume = nullptr;
332 
333  if(m_useCaloSurfBuilder && childCylVolBounds->halflengthZ() > 1000.){
334 
335  // get some output
336  ATH_MSG_VERBOSE ( "[C1] Creating TrackingVolume '" << volumeName );
337 
338  // construct bin utilities
339  std::vector<float> steps;
340  steps.push_back(tileExtendedBounds->innerRadius());
341  steps.push_back(entrySurf[CaloCell_ID::TileExt0].first->bounds().r());
342  steps.push_back(entrySurf[CaloCell_ID::TileExt1].first->bounds().r());
343  steps.push_back(entrySurf[CaloCell_ID::TileExt2].first->bounds().r());
344  steps.push_back(tileExtendedBounds->outerRadius());
345  auto eBU = Trk::BinUtility(steps, Trk::open, Trk::binR);
346 
347  extendedMaterialBinned = Trk::BinnedMaterial(*extendedBarrelProperties,eBU,ltb,matETB);
348 
349  tileExtendedTrackingVolume = new Trk::AlignableTrackingVolume(
350  std::make_unique<Amg::Transform3D>(Amg::Translation3D(childPosition)),
351  tileExtendedBounds,
352  extendedMaterialBinned, 18, volumeName);
353 
354  } else {
355  if ( gapVolBounds ) {
356  gapBounds = std::move(gapVolBounds);
357 
358  } else if (tileExtendedBounds) {
359 
360  // construct bin utilities
361  std::vector<float> steps;
362  steps.push_back(tileExtendedBounds->innerRadius());
363  steps.push_back(entrySurf[CaloCell_ID::TileExt0].first->bounds().r());
364  steps.push_back(entrySurf[CaloCell_ID::TileExt1].first->bounds().r());
365  steps.push_back(entrySurf[CaloCell_ID::TileExt2].first->bounds().r());
366  steps.push_back(tileExtendedBounds->outerRadius());
367  auto eBU = Trk::BinUtility(steps, Trk::open, Trk::binR);
368 
369  extendedMaterialBinned = Trk::BinnedMaterial(*extendedBarrelProperties.get(),eBU,ltb,matETB);
370 
371  tileExtendedTrackingVolume = new Trk::AlignableTrackingVolume(
372  std::make_unique<Amg::Transform3D>(Amg::Translation3D(childPosition)),
373  tileExtendedBounds,
374  extendedMaterialBinned,
375  18,
376  volumeName);
377  }
378  }
379  // and assign it to the right one
380  if (childCylVolBounds->halflengthZ() > 1000.){
381  if (childZposition > 0.) {
382  tilePositiveExtendedBarrel = tileExtendedTrackingVolume;
383  tilePositiveExtendedBarrelBounds = *tileExtendedBounds;
384  } else {
385  tileNegativeExtendedBarrel = tileExtendedTrackingVolume;
386  }
387  } else if (childCylVolBounds->halflengthZ() > 100.) {
388  tileZ = fabs(childZposition)+childCylVolBounds->halflengthZ();
389  }
390  } break;
391  } // end of switch
392  } // end of ? cylVolBounds
393  } //end of ichild loop
394  } // end of treetop loop
395 
396  if (!gapBounds) std::abort();
397  if (!tileBarrelGirderBounds) std::abort();
398  if (!tilePositiveExtendedBarrel) std::abort();
399  if (!tileNegativeExtendedBarrel) std::abort();
400 
401  ATH_MSG_DEBUG( "TileDetDescrManager parsed successfully! " );
402 
403  // combined girder volume
404  {
405  auto tileGirderBounds = std::make_shared<Trk::CylinderVolumeBounds>
406  (tileBarrelGirderBounds->innerRadius(),
407  tileBarrelGirderBounds->outerRadius(),
408  tileZ);
409 
410  tileGirder = new Trk::TrackingVolume(nullptr,
411  std::move(tileGirderBounds),
412  girderProperties,
413  dummyLayers, dummyVolumes,
414  "Calo::Girder::TileCombined");
415  }
416 
417  // build the gap volumes ( crack done by CaloTG )
418  double tileExtZ = tilePositiveExtendedBarrel->center().z()-tilePositiveExtendedBarrelBounds.halflengthZ();
419 
420  // binned material for ITC :
421  std::vector<Trk::IdentifiedMaterial> matITC;
422  // layer material can be adjusted here
423  baseID = Trk::GeometrySignature(Trk::Calo)*1000;
424  matITC.emplace_back(barrelProperties,baseID+15);
425  matITC.emplace_back(barrelProperties,baseID+16);
426  matITC.emplace_back(barrelProperties,baseID+17);
427 
428  // ITCPlug1
429  double p1Z = 0.5*(plug1Z-plug1hZ+tileExtZ);
430  double hp1Z = 0.5*(tileExtZ-plug1Z+plug1hZ);
431  itcPlug1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
432  plug1R,
433  tileBarrelBounds->outerRadius(),
434  hp1Z);
435 
436  Amg::Vector3D itcP1Pos(0.,0.,p1Z);
437  Amg::Vector3D itcP1Neg(0.,0.,-p1Z);
438  auto itcP1PosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(itcP1Pos));
439  auto itcP1NegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(itcP1Neg));
440 
441 
442  std::vector<size_t> dummylay(1,1);
443  std::vector<float> bpsteps{float(plug1R), float(tileBarrelBounds->outerRadius())};
444  auto rBU = Trk::BinUtility(bpsteps, Trk::open, Trk::binR);
445  const Trk::BinUtility& rBUc(rBU);
446  const Trk::BinnedMaterial plug1MatPos(*barrelProperties,rBU,dummylay,matITC);
447  const Trk::BinnedMaterial plug1MatNeg(*barrelProperties,rBUc,dummylay,matITC);
448 
449  Trk::AlignableTrackingVolume* itcPlug1Pos = new Trk::AlignableTrackingVolume(
450  std::move(itcP1PosTransform),
451  itcPlug1Bounds,
452  plug1MatPos,
453  16,
454  "Calo::Detectors::Tile::ITCPlug1Pos");
455 
456  Trk::AlignableTrackingVolume* itcPlug1Neg = new Trk::AlignableTrackingVolume(
457  std::move(itcP1NegTransform),
458  std::shared_ptr<Trk::CylinderVolumeBounds>(itcPlug1Bounds->clone()),
459  plug1MatNeg, 16, "Calo::Detectors::Tile::ITCPlug1Neg");
460 
461  // ITCPlug2
462  double p2Z = 0.5*(plug2Z-plug2hZ+tileExtZ);
463  double hp2Z = 0.5*(tileExtZ-plug2Z+plug2hZ);
464  itcPlug2Bounds =
465  std::make_shared<Trk::CylinderVolumeBounds>(plug2R, plug1R, hp2Z);
466 
467  Amg::Vector3D itcP2Pos(0.,0.,p2Z);
468  Amg::Vector3D itcP2Neg(0.,0.,-p2Z);
469  auto itcP2PosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(itcP2Pos));
470  auto itcP2NegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(itcP2Neg));
471 
472  std::vector<size_t> p2lay(1,0);
473  std::vector<float> p2steps{float(plug2R), float(plug1R)};
474  auto p2BU = Trk::BinUtility(p2steps, Trk::open, Trk::binR);
475  const Trk::BinUtility& p2BUc(p2BU);
476  const Trk::BinnedMaterial plug2MatPos(*barrelProperties,p2BU,p2lay,matITC);
477  const Trk::BinnedMaterial plug2MatNeg(*barrelProperties,p2BUc,p2lay,matITC);
478 
479  Trk::AlignableTrackingVolume* itcPlug2Pos = new Trk::AlignableTrackingVolume(
480  std::move(itcP2PosTransform),
481  itcPlug2Bounds,
482  plug2MatPos,
483  15,
484  "Calo::Detectors::Tile::ITCPlug2Pos");
485 
486  Trk::AlignableTrackingVolume* itcPlug2Neg = new Trk::AlignableTrackingVolume(
487  std::move(itcP2NegTransform),
488  std::shared_ptr<Trk::CylinderVolumeBounds> (itcPlug2Bounds->clone()),
489  plug2MatNeg, 15,
490  "Calo::Detectors::Tile::ITCPlug2Neg");
491 
492  //std::cout <<"ITC Plug2 ok:"<< std::endl;
493 
494  // Gap
495  float gapi = 0.5*(gapZ-gapBounds->halflengthZ()+tileExtZ);
496  double hgZ = 0.5*(tileExtZ-gapZ+gapBounds->halflengthZ());
497  gapBounds = std::make_shared<Trk::CylinderVolumeBounds>(
498  tileBarrelBounds->innerRadius(), plug2R, hgZ);
499 
500  Amg::Vector3D gPos(0.,0.,gapi);
501  Amg::Vector3D gNeg(0.,0.,-gapi);
502  auto gapPosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(gPos));
503  auto gapNegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(gNeg));
504 
505  std::vector<size_t> glay(1,2);
506  std::vector<float> gsteps{float(gapi-gapBounds->halflengthZ()), float(gapi+gapBounds->halflengthZ())};
507  auto gp = Trk::BinUtility(gsteps, Trk::open, Trk::binZ);
508  const Trk::BinnedMaterial gpMat(*barrelProperties,gp,glay,matITC);
509 
510  Trk::AlignableTrackingVolume* gapPos =
511  new Trk::AlignableTrackingVolume(
512  std::move(gapPosTransform),
513  gapBounds, gpMat,
514  17, "Calo::Detectors::Tile::GapPos");
515 
516  std::vector<float> nsteps{float(-gapi-gapBounds->halflengthZ()), float(-gapi+gapBounds->halflengthZ())};
517  auto gn = Trk::BinUtility(nsteps, Trk::open, Trk::binZ);
518  const Trk::BinnedMaterial gnMat(*barrelProperties,gn,glay,matITC);
519 
520  Trk::AlignableTrackingVolume* gapNeg = new Trk::AlignableTrackingVolume(
521  std::move(gapNegTransform),
522  std::shared_ptr<Trk::CylinderVolumeBounds>(gapBounds->clone()),
523  gnMat, 15,
524  "Calo::Detectors::Tile::GapNeg");
525 
526  // add buffer volumes and glue together gap sections
527  float p1i = itcPlug1Pos->center().z()-itcPlug1Bounds->halflengthZ();
528  float p2i = itcPlug2Pos->center().z()-itcPlug2Bounds->halflengthZ();
529  float gi = gapPos->center().z()-gapBounds->halflengthZ();
530  float zgBuff = 0.5*(p1i+gi);
531  float hgBuff = 0.5*(gi-p1i);
532  Amg::Vector3D gBuffPos(0.,0.,zgBuff);
533  Amg::Vector3D gBuffNeg(0.,0.,-zgBuff);
534  auto gBuffPosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(gBuffPos));
535  auto gBuffNegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(gBuffNeg));
536 
537  auto gapBuffBounds = std::make_shared<Trk::CylinderVolumeBounds>(
538  gapBounds->innerRadius(),
539  gapBounds->outerRadius(),
540  hgBuff);
541 
542  Trk::TrackingVolume* gBufferPos = new Trk::TrackingVolume(
543  std::move(gBuffPosTransform), gapBuffBounds, fingerProperties,
544  dummyLayers, dummyVolumes, "Calo::GapVolumes::Tile::GapBufferPos");
545 
546  Trk::TrackingVolume* gBufferNeg = new Trk::TrackingVolume(
547  std::move(gBuffNegTransform),
548  std::shared_ptr<Trk::CylinderVolumeBounds>(gapBuffBounds->clone()),
549  fingerProperties, dummyLayers, dummyVolumes,
550  "Calo::GapVolumes::Tile::GapBufferNeg");
551 
552  Trk::TrackingVolume* positiveGapSector = nullptr;
553  if (gBufferPos) {
554  std::vector<Trk::TrackingVolume*> volsPosGap;
555  volsPosGap.push_back(gBufferPos);
556  volsPosGap.push_back(gapPos);
557  positiveGapSector = m_trackingVolumeCreator->createContainerTrackingVolume
558  (volsPosGap,
559  tileMaterial,
560  "Calo::Container::PositiveGap");
561  }
562  Trk::TrackingVolume* negativeGapSector = nullptr;
563  if (gBufferNeg) {
564  std::vector<Trk::TrackingVolume*> volsNegGap;
565  volsNegGap.push_back(gapNeg);
566  volsNegGap.push_back(gBufferNeg);
567  negativeGapSector = m_trackingVolumeCreator->createContainerTrackingVolume
568  (volsNegGap,
569  tileMaterial,
570  "Calo::Container::NegativeGap");
571  }
572 
573  // plug2 sector
574  float z2Buff = 0.5*(p1i+p2i);
575  float h2Buff = 0.5*(p2i-p1i);
576  Amg::Vector3D p2BuffPos(0.,0.,z2Buff);
577  Amg::Vector3D p2BuffNeg(0.,0.,-z2Buff);
578  auto p2BuffPosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(p2BuffPos));
579  auto p2BuffNegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(p2BuffNeg));
580 
581  auto p2BuffBounds = std::make_shared<Trk::CylinderVolumeBounds>(
582  itcPlug2Bounds->innerRadius(), itcPlug2Bounds->outerRadius(), h2Buff);
583 
584  Trk::TrackingVolume* p2BufferPos = new Trk::TrackingVolume(
585  std::move(p2BuffPosTransform), p2BuffBounds, fingerProperties, dummyLayers,
586  dummyVolumes, "Calo::GapVolumes::Tile::Plug2BufferPos");
587 
588  Trk::TrackingVolume* p2BufferNeg = new Trk::TrackingVolume(
589  std::move(p2BuffNegTransform),
590  std::shared_ptr<Trk::CylinderVolumeBounds>(p2BuffBounds->clone()),
591  fingerProperties, dummyLayers,
592  dummyVolumes, "Calo::GapVolumes::Tile::Plug2BufferNeg");
593 
594  Trk::TrackingVolume* positiveP2Sector = nullptr;
595  if (p2BufferPos) {
596  std::vector<Trk::TrackingVolume*> volsPosP2;
597  volsPosP2.push_back(p2BufferPos);
598  volsPosP2.push_back(itcPlug2Pos);
599  positiveP2Sector = m_trackingVolumeCreator->createContainerTrackingVolume
600  (volsPosP2,
601  tileMaterial,
602  "Calo::Container::PositiveP2");
603  }
604  Trk::TrackingVolume* negativeP2Sector = nullptr;
605  if (itcPlug2Neg) {
606  std::vector<Trk::TrackingVolume*> volsNegP2;
607  volsNegP2.push_back(itcPlug2Neg);
608  volsNegP2.push_back(p2BufferNeg);
609  negativeP2Sector = m_trackingVolumeCreator->createContainerTrackingVolume
610  (volsNegP2,
611  tileMaterial,
612  "Calo::Container::NegativeP2");
613  }
614 
615  // glue ITC sector radially
616  Trk::TrackingVolume* positiveITCSector = nullptr;
617  if (positiveGapSector && positiveP2Sector) {
618  std::vector<Trk::TrackingVolume*> volsITCPos;
619  volsITCPos.push_back(positiveGapSector);
620  volsITCPos.push_back(positiveP2Sector);
621  volsITCPos.push_back(itcPlug1Pos);
622  positiveITCSector = m_trackingVolumeCreator->createContainerTrackingVolume
623  (volsITCPos,
624  tileMaterial,
625  "Calo::Container::ITCPos");
626  }
627  Trk::TrackingVolume* negativeITCSector = nullptr;
628  if (negativeGapSector && negativeP2Sector) {
629  std::vector<Trk::TrackingVolume*> volsITCNeg;
630  volsITCNeg.push_back(negativeGapSector);
631  volsITCNeg.push_back(negativeP2Sector);
632  volsITCNeg.push_back(itcPlug1Neg);
633  negativeITCSector = m_trackingVolumeCreator->createContainerTrackingVolume
634  (volsITCNeg,
635  tileMaterial,
636  "Calo::Container::ITCNeg");
637  }
638 
639  ATH_MSG_DEBUG( "Gap volumes (ITC sector) built " );
640 
641  // ------------------------------ BARREL SECTION COMPLETION --------------------------------------------------
642 
643  // the Finger Gap Volumes to be constructed
644  double rMin = tileBarrelBounds->innerRadius();
645  double rMax = tileBarrelBounds->outerRadius();
646 
647  double zFG = 0.5*(tileBarrelBounds->halflengthZ()+p1i);
648  double hZ = 0.5*(p1i-tileBarrelBounds->halflengthZ());
649  auto tileBarrelFingerGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(rMin,rMax,hZ);
650 
651  Amg::Vector3D pBFPos(0.,0.,zFG);
652  Amg::Vector3D pBFNeg(0.,0.,-zFG);
653  auto bfPosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(pBFPos));
654  auto bfNegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(pBFNeg));
655 
656  tileBarrelPositiveFingerGap = new Trk::TrackingVolume(
657  std::move(bfPosTransform), tileBarrelFingerGapBounds, barrelFingerGapProperties,
658  dummyLayers, dummyVolumes,
659  "Calo::GapVolumes::Tile::BarrelPositiveFingerGap");
660 
661  tileBarrelNegativeFingerGap = new Trk::TrackingVolume(
662  std::move(bfNegTransform),
663  std::shared_ptr<Trk::CylinderVolumeBounds>(
664  tileBarrelFingerGapBounds->clone()),
665  barrelFingerGapProperties, dummyLayers, dummyVolumes,
666  "Calo::GapVolumes::Tile::BarrelNegativeFingerGap");
667 
668  // ------------------------------ ENDCAP SECTION COMPLETION --------------------------------------------------
669 
670  double zBE = tilePositiveExtendedBarrel->center().z()+tilePositiveExtendedBarrelBounds.halflengthZ();
671  zFG = 0.5*(tileZ + zBE);
672  hZ = 0.5*(tileZ - zBE);
673 
674  auto tilePositiveFingerGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(
675  tilePositiveExtendedBarrelBounds.innerRadius(),
676  tilePositiveExtendedBarrelBounds.outerRadius(),
677  hZ);
678 
679  Amg::Vector3D pEFPos(0.,0.,zFG);
680  Amg::Vector3D pEFNeg(0.,0.,-zFG);
681  auto efPosTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(pEFPos));
682  auto efNegTransform = std::make_unique<Amg::Transform3D>(Amg::Translation3D(pEFNeg));
683 
684  tilePositiveFingerGap = new Trk::TrackingVolume(
685  std::move(efPosTransform), tilePositiveFingerGapBounds, fingerGapProperties,
686  dummyLayers, dummyVolumes, "Calo::GapVolumes::Tile::PositiveFingerGap");
687 
688  tileNegativeFingerGap = new Trk::TrackingVolume(
689  std::move(efNegTransform),
690  std::shared_ptr<Trk::CylinderVolumeBounds>(tilePositiveFingerGapBounds->clone()),
691  fingerGapProperties, dummyLayers, dummyVolumes, "Calo::GapVolumes::Tile::NegativeFingerGap");
692 
693  // set the color code for displaying
694  tileBarrel->registerColorCode( 4 );
695  tilePositiveExtendedBarrel->registerColorCode( 4 );
696  tileNegativeExtendedBarrel->registerColorCode( 4 );
697 
698  gapPos->registerColorCode( 4 );
699  gapNeg->registerColorCode( 4 );
700  itcPlug1Pos->registerColorCode( 4 );
701  itcPlug1Neg->registerColorCode( 4 );
702  itcPlug2Pos->registerColorCode( 4 );
703  itcPlug2Neg->registerColorCode( 4 );
704 
705  tileGirder->registerColorCode( 12 );
706 
707  // finalize Tile : glue locally and return 1 volume
708  ATH_MSG_DEBUG( "Gluing Tile volumes" );
709 
710  // glue tile volumes in z
711  std::vector<Trk::TrackingVolume*> tileVols;
712  tileVols.push_back(tileNegativeFingerGap);
713  tileVols.push_back(tileNegativeExtendedBarrel);
714  tileVols.push_back(negativeITCSector);
715  tileVols.push_back(tileBarrelNegativeFingerGap);
716  tileVols.push_back(tileBarrel);
717  tileVols.push_back(tileBarrelPositiveFingerGap);
718  tileVols.push_back(positiveITCSector);
719  tileVols.push_back(tilePositiveExtendedBarrel);
720  tileVols.push_back(tilePositiveFingerGap);
721  Trk::TrackingVolume* tileCombinedSector = m_trackingVolumeCreator->createContainerTrackingVolume
722  (tileVols,
723  tileMaterial,
724  "Calo::Container::Tile::InnerSector");
725 
726  // glue with combined girder
727  std::vector<Trk::TrackingVolume*> tileVolumes;
728  tileVolumes.push_back(tileCombinedSector);
729  tileVolumes.push_back(tileGirder);
730  Trk::TrackingVolume* tile = m_trackingVolumeCreator->createContainerTrackingVolume
731  (tileVolumes,
732  tileMaterial,
733  "Calo::Container::Tile::Combined");
734 
735  ATH_MSG_DEBUG( "Combined Tile built " );
736 
737  tileTrackingVolumes.push_back(tile); // [0]
738  tileTrackingVolumes.push_back(tilePositiveExtendedBarrel);// [1]
739 
740  if (msgLvl(MSG::INFO)) {
741  ATH_MSG_DEBUG( "Checking the existence of all Tracking Volumes:" );
742  ATH_MSG_DEBUG( " -> Tile::Barrel ");
743  printCheckResult(msg(MSG::DEBUG), tileBarrel);
744  ATH_MSG_DEBUG( " -> Tile::PositiveExtendedBarrel ");
745  printCheckResult(msg(MSG::DEBUG), tilePositiveExtendedBarrel);
746  ATH_MSG_DEBUG( " -> Tile::NegativeExtendedBarrel ");
747  printCheckResult(msg(MSG::DEBUG), tileNegativeExtendedBarrel);
748  ATH_MSG_DEBUG( " -> Tile::BarrelPositiveFingerGap ");
749  printCheckResult(msg(MSG::DEBUG), tileBarrelPositiveFingerGap);
750  ATH_MSG_DEBUG( " -> Tile::BarrelNegativeFingerGap ");
751  printCheckResult(msg(MSG::DEBUG), tileBarrelNegativeFingerGap);
752  ATH_MSG_DEBUG( " -> Tile::PositiveFingerGap ");
753  printCheckResult(msg(MSG::DEBUG), tilePositiveFingerGap);
754  ATH_MSG_DEBUG( " -> Tile::NegativeFingerGap ");
755  printCheckResult(msg(MSG::DEBUG), tileNegativeFingerGap);
756  ATH_MSG_DEBUG( " -> Tile::Girder ");
757  printCheckResult(msg(MSG::DEBUG), tileGirder);
758  } // end of detailed output
759 
760  return tileTrackingVolumes;
761 }
762 
763 void Tile::TileVolumeBuilder::printCheckResult(MsgStream& log, const Trk::TrackingVolume* vol)
764 {
765  if (vol) log << "... ok" << endmsg;
766  else log << "... missing" << endmsg;
767 }
768 
769 void Tile::TileVolumeBuilder::printInfo(const PVConstLink& pv) const {
770  const GeoLogVol* lv = pv->getLogVol();
771  std::cout << "New Tile Object:" << lv->getName() << ", made of"
772  << lv->getMaterial()->getName() << "," << lv->getShape()->type()
773  << std::endl;
774  // m_geoShapeConverter->decodeShape(lv->getShape());
775  int igen = 0;
776  Amg::Transform3D transf = pv->getX();
777  printChildren(pv, igen, transf);
778 }
779 
780 void Tile::TileVolumeBuilder::printChildren(
781  const PVConstLink& pv, int igen, const Amg::Transform3D& trIn) const {
782  // subcomponents
783  unsigned int nc = pv->getNChildVols();
784  igen++;
785  std::string cname;
786  for (unsigned int ic = 0; ic < nc; ic++) {
787  Amg::Transform3D transf = trIn * pv->getXToChildVol(ic);
788 
789  const PVConstLink cv = pv->getChildVol(ic);
790  const GeoLogVol* clv = cv->getLogVol();
791  std::cout << " ";
792  std::cout << "subcomponent:" << igen << ":" << ic << ":" << clv->getName()
793  << ", made of" << clv->getMaterial()->getName() << ","
794  << clv->getShape()->type() << std::endl;
795  std::cout << "position:" << "R:" << transf.translation().perp()
796  << ",phi:" << transf.translation().phi()
797  << ",x:" << transf.translation().x()
798  << ",y:" << transf.translation().y()
799  << ",z:" << transf.translation().z() << std::endl;
800  const GeoTrd* trd = dynamic_cast<const GeoTrd*>(clv->getShape());
801  if (trd)
802  std::cout << "trddim:" << trd->getXHalfLength1() << ","
803  << trd->getXHalfLength2() << "," << trd->getYHalfLength1()
804  << "," << trd->getYHalfLength2() << "," << trd->getZHalfLength()
805  << std::endl;
806  const GeoTubs* tub = dynamic_cast<const GeoTubs*>(clv->getShape());
807  if (tub)
808  std::cout << "tubdim:" << tub->getRMin() << "," << tub->getRMax() << ","
809  << tub->getZHalfLength() << std::endl;
810  const GeoPcon* con = dynamic_cast<const GeoPcon*>(clv->getShape());
811  if (con) {
812  const unsigned int nPlanes = con->getNPlanes();
813  for (unsigned int i = 0; i < nPlanes; i++) {
814  std::cout << "polycone:" << i << ":" << con->getRMinPlane(i) << ","
815  << con->getRMaxPlane(i) << "," << con->getZPlane(i)
816  << std::endl;
817  }
818  }
819 
820  if (ic == 0 || cname != clv->getName()) {
821  // m_geoShapeConverter->decodeShape(clv->getShape());
822  printChildren(cv, igen, transf);
823  cname = clv->getName();
824  }
825  }
826 }
Tile::TileVolumeBuilder::m_tileMgrLocation
std::string m_tileMgrLocation
Location of the CaloDetDescrMgr.
Definition: TileVolumeBuilder.h:86
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
GeoAlignmentStore
Ensure that the extensions for the Vector3D are properly loaded.
Definition: GeoAlignmentStore.h:24
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:97
DiscBounds.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Tile::TileVolumeBuilder::m_trackingVolumeCreator
ToolHandle< Trk::ITrackingVolumeCreator > m_trackingVolumeCreator
Second helper for volume creation.
Definition: TileVolumeBuilder.h:89
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
Trk::binZ
@ binZ
Definition: BinningType.h:49
Tile::TileVolumeBuilder::m_tileBarrelLayersPerSampling
unsigned int m_tileBarrelLayersPerSampling
if m_useCaloSurfBuilder == true, number of layers per dead material region or sampling
Definition: TileVolumeBuilder.h:94
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
BinnedArray.h
Trk::BinnedMaterial
Definition: BinnedMaterial.h:31
CaloDepthTool.h
Declaration of CaloDepthTool. Created by Claire Bourdarios, 25.10.2004.
Tile::TileVolumeBuilder::printInfo
void printInfo(const GeoPVConstLink &pv) const
Definition: TileVolumeBuilder.cxx:769
DiscLayer.h
Tile::TileVolumeBuilder::trackingVolumes
virtual std::vector< Trk::TrackingVolume * > trackingVolumes(const CaloDetDescrManager &caloDDM, const GeoAlignmentStore *geoAlign) const override final
TrackingVolumeBuilder interface method - returns vector of ptrs to volumes.
Definition: TileVolumeBuilder.cxx:128
BinningType.h
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
Trk::TrackingVolume::registerColorCode
void registerColorCode(unsigned int icolor)
Register the color code.
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
TileDetDescrManager.h
ReadCellNoiseFromCool.tile
tile
Definition: ReadCellNoiseFromCool.py:92
CaloDetDescriptor.h
Definition of CaloDetDescriptor.
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
GeometryStatics.h
CylinderVolumeBounds.h
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
beamspotman.steps
int steps
Definition: beamspotman.py:505
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileVolumeBuilder.h
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
beamspotman.n
n
Definition: beamspotman.py:731
Tile::TileVolumeBuilder::m_tileBarrelEnvelope
double m_tileBarrelEnvelope
envelope Cover of the Barrel
Definition: TileVolumeBuilder.h:91
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
ITrackingVolumeCreator.h
CylinderSurface.h
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
Tile::TileVolumeBuilder::TileVolumeBuilder
TileVolumeBuilder(const std::string &, const std::string &, const IInterface *)
AlgTool style constructor.
Definition: TileVolumeBuilder.cxx:60
Tile::TileVolumeBuilder::m_trackingVolumeHelper
ToolHandle< Trk::ITrackingVolumeHelper > m_trackingVolumeHelper
Helper Tool to create TrackingVolumes.
Definition: TileVolumeBuilder.h:88
CylinderLayer.h
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition: Volume.h:90
Tile::TileVolumeBuilder::initialize
virtual StatusCode initialize() override final
AlgTool initialize method.
Definition: TileVolumeBuilder.cxx:94
checkCorrelInHIST.gi
dictionary gi
Definition: checkCorrelInHIST.py:404
Tile::TileVolumeBuilder::m_useCaloSurfBuilder
bool m_useCaloSurfBuilder
if true use DetDescr based layering, if false use biequidistant layering
Definition: TileVolumeBuilder.h:93
Trk::BinUtility
Definition: BinUtility.h:39
grepfile.ic
int ic
Definition: grepfile.py:33
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Tile::TileVolumeBuilder::m_surfBuilder
ToolHandle< ICaloSurfaceBuilder > m_surfBuilder
tool required for definition of active volumes
Definition: TileVolumeBuilder.h:96
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
GeoMaterialConverter.h
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::open
@ open
Definition: BinningType.h:40
CylinderBounds.h
Trk::binR
@ binR
Definition: BinningType.h:50
TrackingVolume.h
python.CaloAddPedShiftConfig.default
default
Definition: CaloAddPedShiftConfig.py:43
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
Trk::CylinderVolumeBounds::innerRadius
double innerRadius() const
This method returns the inner radius.
Definition: CylinderVolumeBounds.h:187
DeMoScan.first
bool first
Definition: DeMoScan.py:536
DEBUG
#define DEBUG
Definition: page_access.h:11
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
python.changerun.pv
pv
Definition: changerun.py:81
GeoShapeConverter.h
DiscSurface.h
Tile::TileVolumeBuilder::printCheckResult
static void printCheckResult(MsgStream &log, const Trk::TrackingVolume *vol)
Definition: TileVolumeBuilder.cxx:763
LVL1::gFEXPos
Definition: gFexPos.h:11
Trk::GeoShapeConverter::convert
static std::shared_ptr< CylinderVolumeBounds > convert(const GeoTubs *gtub)
Convert a tubs.
Definition: GeoShapeConverter.cxx:57
Trk::Material
Definition: Material.h:117
Trk::BinnedArray
Definition: BinnedArray.h:38
AthAlgTool
Definition: AthAlgTool.h:26
Trk::TrackingVolume
Definition: TrackingVolume.h:119
Trk::CylinderVolumeBounds::clone
CylinderVolumeBounds * clone() const override
Virtual constructor.
Definition: CylinderVolumeBounds.h:171
Material
@ Material
Definition: MaterialTypes.h:8
AlignableTrackingVolume.h
StoreGateSvc.h
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
Tile::TileVolumeBuilder::m_forceSymmetry
bool m_forceSymmetry
forces volume symmetry between negative/positive part
Definition: TileVolumeBuilder.h:98
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
Material.h
LayerMaterialProperties.h
Tile::TileVolumeBuilder::printChildren
void printChildren(const GeoPVConstLink &pv, int igen, const Amg::Transform3D &trIn) const
Definition: TileVolumeBuilder.cxx:780
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Trk::AlignableTrackingVolume
Definition: AlignableTrackingVolume.h:36
ITrackingVolumeHelper.h
Generated on Tue May 13 2025 21:19:50 for ATLAS Offline Software by   doxygen 1.8.18