ATLAS Offline Software
GeometryBuilderCond.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // GeometryBuilderCond.cxx, (c) ATLAS Detector software
8 
9 // Trk include
10 #include "TrkDetDescrTools/GeometryBuilderCond.h"
11 #include "TrkDetDescrInterfaces/ITrackingVolumeBuilder.h"
12 #include "TrkDetDescrInterfaces/ILayerBuilderCond.h"
13 #include "TrkDetDescrInterfaces/ITrackingVolumeArrayCreator.h"
14 #include "TrkDetDescrInterfaces/ITrackingVolumeHelper.h"
15 #include "TrkVolumes/CylinderVolumeBounds.h"
16 #include "TrkGeometry/TrackingVolume.h"
17 #include "TrkGeometry/TrackingGeometry.h"
18 #include "TrkGeometry/GlueVolumesDescriptor.h"
19 
20 #ifdef TRKDETDESCR_MEMUSAGE
21 #include <unistd.h>
22 #endif
23 
24 // Amg
25 #include "GeoPrimitives/GeoPrimitives.h"
26 // STD
27 #include <map>
28 //Athena
29 #include "AthenaKernel/IOVInfiniteRange.h"
30 // Gaudi
31 #include "GaudiKernel/MsgStream.h"
32 #include "GaudiKernel/SystemOfUnits.h"
33 
34 
35 // constructor
36 Trk::GeometryBuilderCond::GeometryBuilderCond(const std::string& t, const std::string& n, const IInterface* p)
37 : AthAlgTool(t,n,p),
38  TrackingVolumeManipulator(),
39 #ifdef TRKDETDESCR_MEMUSAGE
40  m_memoryLogger(),
41 #endif
42  m_createWorld(true),
43  m_navigationLevel(2),
44  m_worldDimension(),
45  m_worldMaterialProperties(),
46  m_trackingVolumeArrayCreator("Trk::TrackingVolumeArrayCreator/TrackingVolumeArrayCreator"),
47  m_trackingVolumeHelper("Trk::TrackingVolumeHelper/TrackingVolumeHelper"),
48  m_inDetGeometryBuilderCond("", this),
49  m_caloGeometry{},
50  m_caloGeometryBuilderCond("", this),
51  m_hgtdGeometry{},
52  m_hgtdGeometryBuilderCond("", this),
53  m_muonGeometry{},
54  m_muonGeometryBuilderCond("", this),
55  m_compactify(true),
56  m_synchronizeLayers(true)
57 {
58  declareInterface<IGeometryBuilderCond>(this);
59  // by hand declarations
60  declareProperty("CreateWorldManually", m_createWorld);
61  declareProperty("NavigationLevel", m_navigationLevel);
62  // (1) dimension & material
63  declareProperty("WorldDimension", m_worldDimension);
64  declareProperty("WorldMaterialProperties", m_worldMaterialProperties);
65  // tool declarations ----------------------------------------------------------------
66  declareProperty("TrackingVolumeArrayCreator", m_trackingVolumeArrayCreator);
67  declareProperty("TrackingVolumeHelper", m_trackingVolumeHelper);
68  declareProperty("InDetTrackingGeometryBuilder", m_inDetGeometryBuilderCond);
69  declareProperty("HGTD_TrackingGeometryBuilder", m_hgtdGeometryBuilderCond);
70  declareProperty("CaloTrackingGeometryBuilder", m_caloGeometryBuilderCond);
71  declareProperty("MuonTrackingGeometryBuilder", m_muonGeometryBuilderCond);
72  // optimize layer dimension & memory usage -------------------------------
73  declareProperty("Compactify", m_compactify );
74  declareProperty("SynchronizeLayers", m_synchronizeLayers );
75 }
76 
77 // destructor
78 Trk::GeometryBuilderCond::~GeometryBuilderCond()
79 = default;
80 
81 
82 // Athena standard methods
83 // initialize
84 StatusCode Trk::GeometryBuilderCond::initialize()
85 {
86 
87  // Retrieve the volume array creator ----------------------------------------------------
88  ATH_CHECK(m_trackingVolumeArrayCreator.retrieve());
89 
90  // Retrieve the tracking volume helper --------------------------------------------------
91  ATH_CHECK (m_trackingVolumeHelper.retrieve());
92  // Geometries =============================================================================
93  // (I) Inner Detector ---------------------------------------------------------------------
94  if (!m_inDetGeometryBuilderCond.empty()) {
95  ATH_CHECK(m_inDetGeometryBuilderCond.retrieve());
96  }
97  // (H) High Granularity Timing Detector ----------------------------------------------------
98  if(!m_hgtdGeometryBuilderCond.empty()) {
99  if (m_hgtdGeometryBuilderCond.retrieve().isFailure()) {
100  ATH_MSG_FATAL("Failed to retrieve tool " << m_hgtdGeometryBuilderCond );
101  return StatusCode::FAILURE;
102  } else
103  ATH_MSG_INFO( "Retrieved tool " << m_hgtdGeometryBuilderCond );
104  }
105  // (C) Calorimeter --------------------------------------------------------------------------
106  if (!m_caloGeometryBuilderCond.empty()) {
107  ATH_CHECK (m_caloGeometryBuilderCond.retrieve());
108  }
109  // (M) Muon System -------------------------------------------------------------------------
110  if (!m_muonGeometryBuilderCond.empty()) {
111  ATH_CHECK(m_muonGeometryBuilderCond.retrieve());
112  }
113 
114  // if no world dimensions are declared, take default ones
115  if (m_worldDimension.empty())
116  m_worldDimension = std::vector<double>{0.*Gaudi::Units::meter, 10.*Gaudi::Units::meter, 15.*Gaudi::Units::meter};
117 
118  // if no world materials are declared, take default ones - set vacuum
119  if (m_worldMaterialProperties.size() < 5)
120  m_worldMaterialProperties = std::vector<double>{10.e10,10.e10,1e-10, 0., 0.};
121 
122  m_worldMaterial = Trk::Material(m_worldMaterialProperties[0],
123  m_worldMaterialProperties[1],
124  m_worldMaterialProperties[2],
125  m_worldMaterialProperties[3],
126  m_worldMaterialProperties[4]);
127 
128  ATH_MSG_DEBUG( " initialize() successful" );
129 
130  return StatusCode::SUCCESS;
131 }
132 
133 std::unique_ptr< Trk::TrackingGeometry>
134 Trk::GeometryBuilderCond::trackingGeometry(const EventContext& ctx,
135  Trk::TrackingVolume* /*tVol*/,
136  SG::WriteCondHandle<TrackingGeometry>& whandle) const
137 {
138 
139  // the geometry to be constructed
140  std::unique_ptr<Trk::TrackingGeometry> tGeometry;
141  if ( m_inDetGeometryBuilderCond.empty() && m_hgtdGeometryBuilderCond.empty() && m_caloGeometryBuilderCond.empty() && m_muonGeometryBuilderCond.empty() ) {
142 
143  ATH_MSG_VERBOSE( "Configured to only create world TrackingVolume." );
144 
145  Trk::VolumeBounds* worldBounds = new Trk::CylinderVolumeBounds(m_worldDimension[0],
146  m_worldDimension[1],
147  m_worldDimension[2]);
148 
149  Trk::TrackingVolume* worldVolume = new Trk::TrackingVolume(nullptr,
150  worldBounds,
151  m_worldMaterial,
152  nullptr,
153  nullptr,
154  "EmptyWorldVolume");
155  // create a new geometry
156  tGeometry = std::make_unique<Trk::TrackingGeometry>(worldVolume);
157  } else
158  tGeometry = atlasTrackingGeometry(ctx, whandle);
159  // sign it before you return anything
160  tGeometry->sign(geometrySignature());
161  return tGeometry;
162 }
163 
164 
165 std::unique_ptr<Trk::TrackingGeometry>
166 Trk::GeometryBuilderCond::atlasTrackingGeometry(const EventContext& ctx,
167  SG::WriteCondHandle<TrackingGeometry>& whandle) const
168 {
169  // the return geometry
170  std::unique_ptr<Trk::TrackingGeometry> atlasTrackingGeometry;
171 
172  // A ------------- INNER DETECTOR SECTION --------------------------------------------------------------------------------
173  // get the Inner Detector and/or HGTD and/or Calorimeter trackingGeometry
174 
175  // the volumes to be given to higher level tracking geometry builders
176  Trk::TrackingVolume* inDetVolume = nullptr;
177  Trk::TrackingVolume* hgtdVolume = nullptr;
178  Trk::TrackingVolume* caloVolume = nullptr;
179 
180  // mark the highest volume
181  Trk::TrackingVolume* highestVolume = nullptr;
182 
183 #ifdef TRKDETDESCR_MEMUSAGE
184  m_memoryLogger.refresh(getpid());
185  ATH_MSG_INFO( "[ memory usage ] Start of TrackingGeometry building: " );
186  ATH_MSG_INFO( m_memoryLogger );
187 #endif
188 
189  // ========================== INNER DETECTOR PART =================================================
190  if (!m_inDetGeometryBuilderCond.empty()) {
191  // debug output
192  ATH_MSG_VERBOSE( "ID Tracking Geometry is going to be built." );
193  // build the geometry
194  std::unique_ptr<Trk::TrackingGeometry> inDetTrackingGeometry =
195  m_inDetGeometryBuilderCond->trackingGeometry(ctx, nullptr, whandle);
196  // check
197  if (inDetTrackingGeometry) {
198  // sign it
199  inDetTrackingGeometry->sign(m_inDetGeometryBuilderCond->geometrySignature());
200  // check whether the world has to be created or not
201  if (m_createWorld || m_hgtdGeometry || m_caloGeometry || m_muonGeometry) {
202  // checkout the highest InDet volume
203  inDetVolume = inDetTrackingGeometry->checkoutHighestTrackingVolume();
204  // assign it as the highest volume
205  highestVolume = inDetVolume;
206  } else // -> Take the exit and return ID stand alone
207  atlasTrackingGeometry = std::move(inDetTrackingGeometry);
208  }
209 
210 #ifdef TRKDETDESCR_MEMUSAGE
211  m_memoryLogger.refresh(getpid());
212  ATH_MSG_INFO( "[ memory usage ] After InDet TrackingGeometry building: " );
213  ATH_MSG_INFO( m_memoryLogger );
214 #endif
215 
216  }
217 
218  // ========================== HGTD PART =================================================
219  // if a HGTD Geometry Builder is present -> wrap it around the ID
220  if (!m_hgtdGeometryBuilderCond.empty()) {
221  if (inDetVolume)
222  ATH_MSG_VERBOSE( "HGTD Tracking Geometry is going to be built with enclosed ID." );
223  else
224  ATH_MSG_VERBOSE( "HGTD Tracking Geometry is going to be built stand-alone." );
225  // get the InnerDetector TrackingGeometry
226  std::unique_ptr<Trk::TrackingGeometry> hgtdTrackingGeometry =
227  m_hgtdGeometryBuilderCond->trackingGeometry(ctx, inDetVolume, whandle);
228  // if you have to create world or there is a Calo/Muon geometry builder ...
229  if (hgtdTrackingGeometry) {
230  // sign it
231  hgtdTrackingGeometry->sign(m_hgtdGeometryBuilderCond->geometrySignature());
232  if (m_createWorld || m_caloGeometry || m_muonGeometry){
233  // check out the highest Calo volume
234  hgtdVolume = hgtdTrackingGeometry->checkoutHighestTrackingVolume();
235  // assign it as the highest volume (overwrite ID)
236  highestVolume = hgtdVolume;
237  } else // -> Take the exit and return HGTD back
238  atlasTrackingGeometry = std::move(hgtdTrackingGeometry);
239  }
240 
241 #ifdef TRKDETDESCR_MEMUSAGE
242  m_memoryLogger.refresh(getpid());
243  ATH_MSG_INFO( "[ memory usage ] After Calo TrackingGeometry building: " );
244  ATH_MSG_INFO( m_memoryLogger );
245 #endif
246 
247  }
248 
249  // ========================== CALORIMETER PART =================================================
250  // if a Calo Geometry Builder is present -> wrap it around the ID or HGTD
251  if (!m_caloGeometryBuilderCond.empty()) {
252  std::string enclosed = "stand-alone.";
253  if (inDetVolume and hgtdVolume)
254  enclosed = "with encloded ID/HGTD.";
255  else if (inDetVolume or hgtdVolume)
256  enclosed = (inDetVolume) ? "with encloded ID." : "with encloded HGTD.";
257  ATH_MSG_VERBOSE( "Calorimeter Tracking Geometry is going to be built "<< enclosed );
258 
259  // get the InnerDetector TrackingGeometry or the HGTD tracking geometry
260  std::unique_ptr<Trk::TrackingGeometry> caloTrackingGeometry;
261  if (inDetVolume and not hgtdVolume)
262  caloTrackingGeometry = m_caloGeometryBuilderCond->trackingGeometry(ctx, inDetVolume, whandle);
263  else
264  caloTrackingGeometry = m_caloGeometryBuilderCond->trackingGeometry(ctx, hgtdVolume, whandle);
265  // if you have to create world or there is a Muon geometry builder ...
266  if (caloTrackingGeometry) {
267  // sign it
268  caloTrackingGeometry->sign(m_caloGeometryBuilderCond->geometrySignature());
269  if (m_createWorld || m_muonGeometry){
270  // check out the highest Calo volume
271  caloVolume = caloTrackingGeometry->checkoutHighestTrackingVolume();
272  // assign it as the highest volume (overwrite ID)
273  highestVolume = caloVolume;
274  } else // -> Take the exit and return Calo back
275  atlasTrackingGeometry = std::move(caloTrackingGeometry);
276  }
277 
278 #ifdef TRKDETDESCR_MEMUSAGE
279  m_memoryLogger.refresh(getpid());
280  ATH_MSG_INFO( "[ memory usage ] After Calo TrackingGeometry building: " );
281  ATH_MSG_INFO( m_memoryLogger );
282 #endif
283 
284  }
285 
286  // ========================== MUON SYSTEM PART =================================================
287  // if Muon Geometry Builder is present -> wrap either ID or Calo
288  if (!m_muonGeometryBuilderCond.empty()) {
289  std::string enclosed = "stand-alone.";
290  if (inDetVolume and hgtdVolume and caloVolume )
291  enclosed = "with encloded ID/HGTD/Calo.";
292  else if (inDetVolume or hgtdVolume or caloVolume) {
293  if (inDetVolume) {
294  if (hgtdVolume)
295  enclosed = "with encloded ID/HGTD";
296  else if (caloVolume)
297  enclosed = "with encloded ID/Calo";
298  else
299  enclosed = "with encloded ID";
300  } else if (hgtdVolume) {
301  if (caloVolume)
302  enclosed = "with encloded HGTD/Calo";
303  else
304  enclosed = "with encloded HGTD";
305  } else {
306  enclosed = "with encloded Calo";
307  }
308  }
309  ATH_MSG_VERBOSE( "Muon System Tracking Geometry is going to be built "<< enclosed );
310 
311  // there's nothing outside the muons -- wrap the calo or the HGTD if one or both of them exist
312  if (inDetVolume and not hgtdVolume and not caloVolume)
313  atlasTrackingGeometry = m_muonGeometryBuilderCond->trackingGeometry(ctx, inDetVolume, whandle);
314  else if (hgtdVolume and not caloVolume)
315  atlasTrackingGeometry = m_muonGeometryBuilderCond->trackingGeometry(ctx, hgtdVolume, whandle);
316  else
317  atlasTrackingGeometry = m_muonGeometryBuilderCond->trackingGeometry(ctx, caloVolume, whandle);
318 
319  // sign it
320  if (atlasTrackingGeometry)
321  atlasTrackingGeometry->sign(m_muonGeometryBuilderCond->geometrySignature());
322 
323 #ifdef TRKDETDESCR_MEMUSAGE
324  m_memoryLogger.refresh(getpid());
325  ATH_MSG_INFO( "[ memory usage ] After Muon TrackingGeometry building: " );
326  ATH_MSG_INFO( m_memoryLogger );
327 #endif
328 
329  // ========================== WRAPPING SECTION FOR ID/CALO ====================================
330  } else if (m_createWorld && highestVolume) {
331  // wrapping and world creation has been switched on
332  ATH_MSG_VERBOSE( "Enclosing world is going to be built for: " << highestVolume->volumeName() );
333  // get the glue volumes
334  Trk::GlueVolumesDescriptor& innerGlueVolumes = highestVolume->glueVolumesDescriptor();
335  // some screen output
336  ATH_MSG_VERBOSE( "Retrieved with following glue volumes: " << innerGlueVolumes );
337  // at negative face
338  const std::vector<Trk::TrackingVolume*>& innerNegativeFaceVolumes = innerGlueVolumes.glueVolumes(Trk::negativeFaceXY);
339  // at cylinder cover
340  const std::vector<Trk::TrackingVolume*>& innerCentralFaceVolumes = innerGlueVolumes.glueVolumes(Trk::cylinderCover);
341  // at positive face
342  const std::vector<Trk::TrackingVolume*>& innerPositiveFaceVolumes = innerGlueVolumes.glueVolumes(Trk::positiveFaceXY);
343 
344  // get the dimensions
345  // cast them to CylinderVolumeBounds
346  const Trk::CylinderVolumeBounds* innerVolumeBounds = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(highestVolume->volumeBounds()));
347  if (!innerVolumeBounds) ATH_MSG_WARNING( "atlasTrackingGeometry() ... dynamic cast to innerVolumeBounds failed!" );
348  double innerVolumeOuterR = innerVolumeBounds ? innerVolumeBounds->outerRadius() : 0;
349  double innerVolumeHalflengthZ = innerVolumeBounds ? innerVolumeBounds->halflengthZ() : 0;
350  // Hierarchy after enclosing
351  //
352  // AtlasWorldVolume:
353  // AtlasInnerCylinder
354  // AtlasInnerNegativeSector
355  // InnerEnclosedVolume (can be ID/Calo)
356  // AtlasOuterNegativeSector
357  // AtlasOuterTube
358  // B -------------- BUILD WORLD AROUND for ID stand alone applications
359 
360  double innerCylinderSectorHalflengthZ = 0.5*(m_worldDimension[2] - innerVolumeHalflengthZ);
361  Trk::CylinderVolumeBounds* innerCylinderSectorBounds =
362  new Trk::CylinderVolumeBounds(0., innerVolumeOuterR, innerCylinderSectorHalflengthZ);
363 
364  double innerCylinderSectorPositionZ = fabs(m_worldDimension[2]-innerCylinderSectorHalflengthZ);
365 
366  // the AtlasInnerNegativeSector
367  Amg::Transform3D* atlasInnerNegativeSectorTransf = new Amg::Transform3D;
368  (*atlasInnerNegativeSectorTransf) = Amg::Translation3D(0.,0.,-innerCylinderSectorPositionZ);
369  Trk::TrackingVolume* atlasInnerNegativeSector = new Trk::TrackingVolume(
370  atlasInnerNegativeSectorTransf,
371  innerCylinderSectorBounds,
372  m_worldMaterial,
373  nullptr,
374  nullptr,
375  "AtlasInnerNegativeSector");
376 
377  // the AtlasInnerPositiveSector
378  Amg::Transform3D* atlasInnerPositiveSectorTransf = new Amg::Transform3D;
379  (*atlasInnerPositiveSectorTransf) = Amg::Translation3D(0.,0.,innerCylinderSectorPositionZ);
380  Trk::TrackingVolume* atlasInnerPositiveSector = new Trk::TrackingVolume(
381  atlasInnerPositiveSectorTransf,
382  innerCylinderSectorBounds->clone(),
383  m_worldMaterial,
384  nullptr,
385  nullptr,
386  "AtlasInnerPositiveSector");
387 
388  ATH_MSG_VERBOSE( "Inner Negative/Positive Sectors built successfully." );
389 
390  // create the subvolume Array
391  auto atlasInnerSectorVolumes = std::vector<Trk::TrackingVolume*>{atlasInnerNegativeSector,highestVolume,atlasInnerPositiveSector};
392 
393  ATH_MSG_VERBOSE( "Create the Atlas Inner Sector volumes. " );
394  Trk::BinnedArray<Trk::TrackingVolume>* atlasInnerSectorVolumeArray = m_trackingVolumeArrayCreator ?
395  m_trackingVolumeArrayCreator->cylinderVolumesArrayInZ(atlasInnerSectorVolumes) : nullptr;
396 
397 
398  // Atlas inner Sector bounds
399  Trk::CylinderVolumeBounds* innerSectorBounds =
400  new Trk::CylinderVolumeBounds(0., innerVolumeOuterR, m_worldDimension[2]);
401  // build the Tracking volumes
402  Trk::TrackingVolume* atlasInnerSector = new Trk::TrackingVolume(nullptr,
403  innerSectorBounds,
404  m_worldMaterial,
405  nullptr,
406  atlasInnerSectorVolumeArray,
407  "AtlasInnerSector");
408 
409  // Atlas outer Sector
410  Trk::CylinderVolumeBounds* outerSectorBounds =
411  new Trk::CylinderVolumeBounds(innerVolumeOuterR, m_worldDimension[1], m_worldDimension[2]);
412  Trk::TrackingVolume* atlasOuterSector = new Trk::TrackingVolume(nullptr,
413  outerSectorBounds,
414  m_worldMaterial,
415  nullptr,
416  nullptr,
417  "AtlasOuterSector");
418 
419  ATH_MSG_VERBOSE( "Atlas Inner/Outer Sectors built successfully." );
420 
421  // create the array of Inner and Outer sector
422  auto atlasVolumes = std::vector<Trk::TrackingVolume*>{atlasInnerSector, atlasOuterSector};
423 
424  Trk::BinnedArray<Trk::TrackingVolume>* atlasVolumeArray = m_trackingVolumeArrayCreator ?
425  m_trackingVolumeArrayCreator->cylinderVolumesArrayInR(atlasVolumes) : nullptr;
426 
427  // create the Atlas volume bounds
428  Trk::CylinderVolumeBounds* atlasBounds = new Trk::CylinderVolumeBounds(0., m_worldDimension[1], m_worldDimension[2]);
429 
430  // create the Atlas TrackingVolume
431  Trk::TrackingVolume* atlasVolume = new Trk::TrackingVolume(nullptr,
432  atlasBounds,
433  m_worldMaterial,
434  nullptr,
435  atlasVolumeArray,
436  "Atlas");
437 
438  ATH_MSG_VERBOSE( "Atlas Tracking World volume built successfully." );
439 
440 
441  // glue the inner sector to be complete
442  m_trackingVolumeHelper->glueTrackingVolumes( *atlasInnerNegativeSector, Trk::positiveFaceXY,
443  innerNegativeFaceVolumes, Trk::negativeFaceXY );
444 
445  m_trackingVolumeHelper->glueTrackingVolumes( *atlasInnerPositiveSector, Trk::negativeFaceXY,
446  innerPositiveFaceVolumes, Trk::positiveFaceXY );
447 
448  ATH_MSG_VERBOSE( "Atlas Inner Sector glued successfully together." );
449 
450  // iterators to the face volumes
451  auto volIter = innerCentralFaceVolumes.begin();
452  auto volIterEnd = innerCentralFaceVolumes.end();
453 
454  // glue outer and inner sector together
455  std::vector<Trk::TrackingVolume*> atlasInnerOuterVolumes;
456  atlasInnerOuterVolumes.push_back(atlasInnerNegativeSector);
457  for ( ; volIter != volIterEnd; ++volIter)
458  if (*volIter) atlasInnerOuterVolumes.push_back(*volIter);
459  atlasInnerOuterVolumes.push_back(atlasInnerPositiveSector);
460 
461  m_trackingVolumeHelper->glueTrackingVolumes(*atlasOuterSector, Trk::tubeInnerCover,
462  atlasInnerOuterVolumes, Trk::tubeOuterCover);
463 
464  ATH_MSG_VERBOSE( "Atlas Inner/Outer Sector glued successfully together." );
465 
466  // job done -> create the TrackingGeometry
467  atlasTrackingGeometry = std::make_unique<Trk::TrackingGeometry>(atlasVolume);
468 
469  // detailed information about this tracking geometry
470  ATH_MSG_VERBOSE( "Atlas TrackingGeometry built with following parameters : ");
471  //ATH_MSG_VERBOSE( " - TrackingVolume containers : " << atlasTrackingGeometry->numberOfContainerVolumes() );
472  //ATH_MSG_VERBOSE( " - TrackingVolume at navigation level : " << atlasTrackingGeometry->numberOfContainerVolumes() );
473  //ATH_MSG_VERBOSE( " - Contained static layers : " << atlasTrackingGeometry->boundaryLayers().size());
474  ATH_MSG_VERBOSE( " - Unique material layers on boundaries : " << atlasTrackingGeometry->boundaryLayers().size());
475 
476 #ifdef TRKDETDESCR_MEMUSAGE
477  m_memoryLogger.refresh(getpid());
478  ATH_MSG_INFO( "[ memory usage ] After Outer Sector TrackingGeometry building: " );
479  ATH_MSG_INFO( m_memoryLogger );
480 #endif
481 
482  }
483 
484  if (atlasTrackingGeometry) {
485  if (m_navigationLevel < 3)
486  atlasTrackingGeometry->registerNavigationLevel( Trk::NavigationLevel(m_navigationLevel));
487  }
488  else ATH_MSG_WARNING( "atlasTrackingGeometry() ... atlasTrackingGeometry = 0, could not call registerNavigationLevel and propagateMagneticFieldProperties" );
489 
490 #ifdef TRKDETDESCR_MEMUSAGE
491  m_memoryLogger.refresh(getpid());
492  ATH_MSG_INFO( "[ memory usage ] End of TrackingGeometry building: " );
493  ATH_MSG_INFO( m_memoryLogger );
494 #endif
495 
496  // synchronize the layers
497  if (atlasTrackingGeometry) {
498  if (m_synchronizeLayers) atlasTrackingGeometry->synchronizeLayers(msg());
499 
500  // compactify if configured to do so
501  if (m_compactify) atlasTrackingGeometry->compactify(msg());
502  }
503  return atlasTrackingGeometry;
504 }
Trk::TrackingVolumeManipulator
Definition: TrackingVolumeManipulator.h:32
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
Trk::TrackingVolume::glueVolumesDescriptor
GlueVolumesDescriptor & glueVolumesDescriptor()
Definition: TrackingVolume.cxx:1205
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ITrackingVolumeBuilder.h
Trk::GeometryBuilderCond::trackingGeometry
virtual std::unique_ptr< Trk::TrackingGeometry > trackingGeometry(const EventContext &ctx, Trk::TrackingVolume *tVol, SG::WriteCondHandle< TrackingGeometry > &whandle) const override
TrackingGeometry Interface method - optionally a pointer to Bounds Interface marked as not thread saf...
Definition: GeometryBuilderCond.cxx:134
Trk::positiveFaceXY
@ positiveFaceXY
Definition: BoundarySurfaceFace.h:33
Trk::GeometryBuilderCond::atlasTrackingGeometry
std::unique_ptr< Trk::TrackingGeometry > atlasTrackingGeometry(const EventContext &ctx, SG::WriteCondHandle< TrackingGeometry > &whandle) const
TrackingGeometry for ATLAS setup.
Definition: GeometryBuilderCond.cxx:166
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ITrackingVolumeArrayCreator.h
Trk::TrackingGeometry::synchronizeLayers
void synchronizeLayers(MsgStream &msgstream, TrackingVolume *vol=nullptr)
Geometry Builder business: synchronize all layers to enclosed volume dimensions.
Definition: TrackingGeometry.cxx:162
GeoPrimitives.h
Trk::VolumeBounds
Definition: VolumeBounds.h:45
CylinderVolumeBounds.h
Trk::NavigationLevel
NavigationLevel
Definition: TrackingGeometry.h:43
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
python.SystemOfUnits.meter
int meter
Definition: SystemOfUnits.py:61
beamspotman.n
n
Definition: beamspotman.py:731
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
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::negativeFaceXY
@ negativeFaceXY
Definition: BoundarySurfaceFace.h:32
Trk::TrackingGeometry::compactify
void compactify(MsgStream &msgstream, TrackingVolume *vol=nullptr)
Geometry Builder busineess: set all contained surfaces TG owned - this should save memory and avoid s...
Definition: TrackingGeometry.cxx:141
Trk::TrackingGeometry::sign
void sign(GeometrySignature geosit, GeometryType geotype=Static)
Geometry Builder busineess: the geometry builder has to sign.
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
IOVInfiniteRange.h
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
GlueVolumesDescriptor.h
Trk::GlueVolumesDescriptor::glueVolumes
const std::vector< TrackingVolume * > & glueVolumes(BoundarySurfaceFace)
retrieve them again
Definition: GlueVolumesDescriptor.cxx:40
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
Trk::TrackingGeometry::registerNavigationLevel
void registerNavigationLevel(NavigationLevel navlevel)
private method the Navigation Level
Trk::GeometryBuilderCond::GeometryBuilderCond
GeometryBuilderCond(const std::string &, const std::string &, const IInterface *)
Constructor.
Definition: GeometryBuilderCond.cxx:36
Trk::TrackingGeometry::boundaryLayers
const std::map< Layer *, int > & boundaryLayers()
Return the unique BoundarySurfaces with MaterialInformation.
Trk::GlueVolumesDescriptor
Definition: GlueVolumesDescriptor.h:40
TrackingVolume.h
Trk::GeometryBuilderCond::initialize
virtual StatusCode initialize() override
AlgTool initialize method.
Definition: GeometryBuilderCond.cxx:84
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::GeometryBuilderCond::~GeometryBuilderCond
virtual ~GeometryBuilderCond()
Destructor.
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
Trk::TrackingGeometry::checkoutHighestTrackingVolume
TrackingVolume * checkoutHighestTrackingVolume()
private method to be called from GeometryBuilder: return the world with ownership
Definition: TrackingGeometry.cxx:169
Trk::Volume::volumeBounds
const VolumeBounds & volumeBounds() const
returns the volumeBounds()
Definition: Volume.h:97
Trk::cylinderCover
@ cylinderCover
Definition: BoundarySurfaceFace.h:38
Trk::tubeOuterCover
@ tubeOuterCover
Definition: BoundarySurfaceFace.h:40
TrackingGeometry.h
Trk::tubeInnerCover
@ tubeInnerCover
Definition: BoundarySurfaceFace.h:39
Trk::BinnedArray
Definition: BinnedArray.h:38
AthAlgTool
Definition: AthAlgTool.h:26
GeometryBuilderCond.h
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
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
ILayerBuilderCond.h
ITrackingVolumeHelper.h
Generated on Thu Nov 7 2024 21:15:43 for ATLAS Offline Software by   doxygen 1.8.18