Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
ActsTrackingGeometrySvc Class Reference

#include <ActsTrackingGeometrySvc.h>

Inheritance diagram for ActsTrackingGeometrySvc:
Collaboration diagram for ActsTrackingGeometrySvc:

Public Member Functions

StatusCode initialize () override
 
 ActsTrackingGeometrySvc (const std::string &name, ISvcLocator *pSvcLocator)
 
std::shared_ptr< const Acts::TrackingGeometry > trackingGeometry () override
 
unsigned int populateAlignmentStore (ActsTrk::DetectorAlignStore &store) const override
 
const ActsGeometryContext & getNominalContext () const override
 

Private Member Functions

ActsLayerBuilder::Config makeLayerBuilderConfig (const InDetDD::InDetDetectorManager *manager)
 
std::shared_ptr< const Acts::ILayerBuilder > makeStrawLayerBuilder (const InDetDD::InDetDetectorManager *manager)
 
std::shared_ptr< const Acts::ILayerBuilder > makeHGTDLayerBuilder (const HGTD_DetectorManager *manager)
 
std::shared_ptr< Acts::TrackingVolume > makeSCTTRTAssembly (const Acts::GeometryContext &gctx, const Acts::ILayerBuilder &sct_lb, const Acts::ILayerBuilder &trt_lb, const Acts::CylinderVolumeHelper &cvh, const std::shared_ptr< const Acts::TrackingVolume > &pixel)
 
Acts::CylinderVolumeBuilder::Config makeBeamPipeConfig (std::shared_ptr< const Acts::CylinderVolumeHelper > cvh) const
 
bool runConsistencyChecks () const
 

Private Attributes

ServiceHandle< StoreGateSvc > m_detStore
 
const InDetDD::SiDetectorManager * p_pixelManager {nullptr}
 
const InDetDD::SiDetectorManager * p_SCTManager {nullptr}
 
const InDetDD::TRT_DetectorManager * p_TRTManager {nullptr}
 
const InDetDD::SiDetectorManager * p_ITkPixelManager {nullptr}
 
const InDetDD::SiDetectorManager * p_ITkStripManager {nullptr}
 
const BeamPipeDetectorManager * p_beamPipeMgr {nullptr}
 
const HGTD_DetectorManager * p_HGTDManager {nullptr}
 
std::shared_ptr< ActsElementVector > m_elementStore {nullptr}
 
std::shared_ptr< const Acts::TrackingGeometry > m_trackingGeometry {nullptr}
 
const TRT_ID * m_TRT_idHelper {nullptr}
 
const HGTD_ID * m_HGTD_idHelper {nullptr}
 
ActsGeometryContext m_nominalContext {}
 
Gaudi::Property< bool > m_useMaterialMap {this, "UseMaterialMap", false, ""}
 
Gaudi::Property< bool > m_objDebugOutput {this, "ObjDebugOutput", false, ""}
 
Gaudi::Property< std::string > m_materialMapInputFileBase {this, "MaterialMapInputFile", "", ""}
 
Gaudi::Property< std::string > m_materialMapCalibFolder {this, "MaterialMapCalibFolder", ".", ""}
 
Gaudi::Property< bool > m_buildBeamPipe {this, "BuildBeamPipe", false, ""}
 
Gaudi::Property< std::vector< size_t > > m_barrelMaterialBins {this, "BarrelMaterialBins", {10, 10}}
 
Gaudi::Property< std::vector< size_t > > m_endcapMaterialBins {this, "EndcapMaterialBins", {5, 20}}
 
Gaudi::Property< std::vector< std::string > > m_buildSubdetectors {this, "BuildSubDetectors", {"Pixel", "SCT", "TRT", "Calo", "HGTD", "Muon"}}
 
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerRadii {this, "PassiveITkInnerPixelBarrelLayerRadii", {}}
 the specifications for building additional passive cylinders in the barrel region: for each cylinder you want to specify radius, half length in z and thickness More...
 
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerHalflengthZ {this, "PassiveITkInnerPixelBarrelLayerHalflengthZ", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerThickness {this, "PassiveITkInnerPixelBarrelLayerThickness", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerRadii {this, "PassiveITkOuterPixelBarrelLayerRadii", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerHalflengthZ {this, "PassiveITkOuterPixelBarrelLayerHalflengthZ", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerThickness {this, "PassiveITkOuterPixelBarrelLayerThickness", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerRadii {this, "PassiveITkStripBarrelLayerRadii", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerHalflengthZ {this, "PassiveITkStripBarrelLayerHalflengthZ", {}}
 
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerThickness {this, "PassiveITkStripBarrelLayerThickness", {}}
 
BooleanProperty m_runConsistencyChecks
 
StringProperty m_consistencyCheckOutput
 
Gaudi::Property< size_t > m_consistencyCheckPoints
 
ToolHandle< IActsTrackingVolumeBuilder > m_caloVolumeBuilder
 
ToolHandle< IActsTrackingVolumeBuilder > m_msVolumeBuilder
 
Gaudi::Property< std::vector< unsigned int > > m_subDetNoAlignProp {this, "NotAlignDetectors", {}}
 Define the subdetectors for which the tracking geometry does not expect a valid alignment store. More...
 
std::set< ActsTrk::DetectorType > m_subDetNoAlign {}
 

Detailed Description

Definition at line 51 of file ActsTrackingGeometrySvc.h.

Constructor & Destructor Documentation

◆ ActsTrackingGeometrySvc()

ActsTrackingGeometrySvc::ActsTrackingGeometrySvc ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 61 of file ActsTrackingGeometrySvc.cxx.

63  : base_class(name, svc),
64  m_detStore("StoreGateSvc/DetectorStore", name),
65  m_elementStore (std::make_shared<ActsElementVector>())
66 {
67 }

Member Function Documentation

◆ getNominalContext()

const ActsGeometryContext & ActsTrackingGeometrySvc::getNominalContext ( ) const
override

Definition at line 1061 of file ActsTrackingGeometrySvc.cxx.

1061 { return m_nominalContext; }

◆ initialize()

StatusCode ActsTrackingGeometrySvc::initialize ( )
override

Definition at line 69 of file ActsTrackingGeometrySvc.cxx.

69  {
70  ATH_MSG_INFO(name() << " is initializing");
71  for (unsigned int skipAlign : m_subDetNoAlignProp) {
72  try {
73  m_subDetNoAlign.insert(static_cast<DetectorType>(skipAlign));
74  } catch (...) {
75  ATH_MSG_FATAL("Failed to interpret " << m_subDetNoAlignProp << " as ActsDetectorElements");
76  return StatusCode::FAILURE;
77  }
78 }
79 
80  // FIXME: ActsCaloTrackingVolumeBuilder holds ReadHandle to
81  // CaloDetDescrManager. Hopefully this service is never called before that
82  // object is available.
83  m_autoRetrieveTools = false;
84  m_checkToolDeps = false;
85 
86  ATH_MSG_INFO("ACTS version is: v"
87  << Acts::VersionMajor << "." << Acts::VersionMinor << "."
88  << Acts::VersionPatch << " [" << Acts::CommitHash << "]");
89 
90  // load which subdetectors to build from property
91  std::set<std::string> buildSubdet(m_buildSubdetectors.begin(),
92  m_buildSubdetectors.end());
93  ATH_MSG_INFO("Configured to build " << buildSubdet.size()
94  << " subdetectors:");
95  for (const auto &s : buildSubdet) {
96  ATH_MSG_INFO(" - " << s);
97  }
98 
99  ATH_MSG_DEBUG("Loading detector manager(s)");
100  if (buildSubdet.find("Pixel") != buildSubdet.end()) {
101  ATH_CHECK(m_detStore->retrieve(p_pixelManager, "Pixel"));
102  }
103  if (buildSubdet.find("SCT") != buildSubdet.end()) {
104  ATH_CHECK(m_detStore->retrieve(p_SCTManager, "SCT"));
105  }
106  if (buildSubdet.find("TRT") != buildSubdet.end()) {
107  ATH_CHECK(m_detStore->retrieve(p_TRTManager, "TRT"));
108  ATH_CHECK(m_detStore->retrieve(m_TRT_idHelper, "TRT_ID"));
109  }
110  if (buildSubdet.find("ITkPixel") != buildSubdet.end()) {
111  ATH_CHECK(m_detStore->retrieve(p_ITkPixelManager, "ITkPixel"));
112  }
113  if (buildSubdet.find("ITkStrip") != buildSubdet.end()) {
114  ATH_CHECK(m_detStore->retrieve(p_ITkStripManager, "ITkStrip"));
115  }
116  if (buildSubdet.find("HGTD") != buildSubdet.end()) {
117  ATH_CHECK(m_detStore->retrieve(p_HGTDManager, "HGTD"));
118  ATH_CHECK(m_detStore->retrieve(m_HGTD_idHelper, "HGTD_ID"));
119  }
120 
121  if(m_buildBeamPipe) {
122  ATH_CHECK(m_detStore->retrieve(p_beamPipeMgr, "BeamPipe"));
123  }
124 
125  // Consistency check on the size vectors for passive layers
126  if (m_passiveITkInnerPixelBarrelLayerRadii.size() != m_passiveITkInnerPixelBarrelLayerHalflengthZ.size() ||
127  m_passiveITkInnerPixelBarrelLayerHalflengthZ.size() != m_passiveITkInnerPixelBarrelLayerThickness.size()) {
128  ATH_MSG_FATAL("Consistency check for ITk inner pixel barrel passive layer construction failed. Please check your inputs! ");
129  return StatusCode::FAILURE;
130  }
131 
132  if (m_passiveITkOuterPixelBarrelLayerRadii.size() != m_passiveITkOuterPixelBarrelLayerHalflengthZ.size() ||
133  m_passiveITkOuterPixelBarrelLayerHalflengthZ.size() != m_passiveITkOuterPixelBarrelLayerThickness.size()) {
134  ATH_MSG_FATAL("Consistency check for ITk outer pixel barrel passive layer construction failed. Please check your inputs! ");
135  return StatusCode::FAILURE;
136  }
137 
138  if (m_passiveITkStripBarrelLayerRadii.size() != m_passiveITkStripBarrelLayerHalflengthZ.size() ||
139  m_passiveITkStripBarrelLayerHalflengthZ.size() != m_passiveITkStripBarrelLayerThickness.size()) {
140  ATH_MSG_FATAL("Consistency check for ITk strip barrel passive layer construction failed. Please check your inputs! ");
141  return StatusCode::FAILURE;
142  }
143 
144  ATH_MSG_DEBUG("Setting up ACTS geometry helpers");
145 
146  Acts::LayerArrayCreator::Config lacCfg;
147  auto layerArrayCreator = std::make_shared<const Acts::LayerArrayCreator>(
148  lacCfg, makeActsAthenaLogger(this, std::string("LayArrCrtr"), std::string("ActsTGSvc")));
149 
150  Acts::TrackingVolumeArrayCreator::Config tvcCfg;
151  auto trackingVolumeArrayCreator =
152  std::make_shared<const Acts::TrackingVolumeArrayCreator>(
153  tvcCfg, makeActsAthenaLogger(this, std::string("TrkVolArrCrtr"), std::string("ActsTGSvc")));
154 
155  Acts::CylinderVolumeHelper::Config cvhConfig;
156  cvhConfig.layerArrayCreator = layerArrayCreator;
157  cvhConfig.trackingVolumeArrayCreator = trackingVolumeArrayCreator;
158 
159  auto cylinderVolumeHelper =
160  std::make_shared<const Acts::CylinderVolumeHelper>(
161  cvhConfig, makeActsAthenaLogger(this, std::string("CylVolHlpr"), std::string("ActsTGSvc")));
162 
163  Acts::TrackingGeometryBuilder::Config tgbConfig;
164  tgbConfig.trackingVolumeHelper = cylinderVolumeHelper;
165 
166  if (m_useMaterialMap) {
167  std::shared_ptr<const Acts::IMaterialDecorator> matDeco = nullptr;
168 
169  std::string matFileFullPath = PathResolverFindCalibFile(m_materialMapCalibFolder.value()+"/"+m_materialMapInputFileBase.value());
170  if (matFileFullPath.empty()) {
171  ATH_MSG_ERROR( "Material Map Input File " << m_materialMapCalibFolder.value() << "/" << m_materialMapInputFileBase.value() << " not found.");
172  return StatusCode::FAILURE;
173  }
174  ATH_MSG_INFO("Configured to use material input: " << matFileFullPath);
175 
176  if (matFileFullPath.find(".json") != std::string::npos) {
177  // Set up the converter first
178  Acts::MaterialMapJsonConverter::Config jsonGeoConvConfig;
179  // Set up the json-based decorator
180  matDeco = std::make_shared<const Acts::JsonMaterialDecorator>(
181  jsonGeoConvConfig, matFileFullPath, ActsTrk::actsLevelVector(msg().level()));
182  }
183  tgbConfig.materialDecorator = matDeco;
184  }
185 
186  std::array<double, 2> sctECEnvelopeZ{20_mm, 20_mm};
187 
188  try {
189  // BeamPipe
190  if(m_buildBeamPipe) {
191  tgbConfig.trackingVolumeBuilders.push_back([&](const auto &gctx,
192  const auto &inner,
193  const auto &) {
194 
195  Acts::CylinderVolumeBuilder::Config bpvConfig =
196  makeBeamPipeConfig(cylinderVolumeHelper);
197 
198  Acts::CylinderVolumeBuilder beamPipeVolumeBuilder {
199  bpvConfig, makeActsAthenaLogger(this, std::string("BPVolBldr"), std::string("ActsTGSvc"))};
200 
201  return beamPipeVolumeBuilder.trackingVolume(gctx, inner);
202  });
203  }
204 
205 
206 
207  // PIXEL
208  if (buildSubdet.count("Pixel") > 0) {
209  tgbConfig.trackingVolumeBuilders.push_back([&](const auto &gctx,
210  const auto &inner,
211  const auto &) {
212  auto cfg = makeLayerBuilderConfig(p_pixelManager);
213  cfg.mode = ActsLayerBuilder::Mode::Pixel;
214  auto lb = std::make_shared<ActsLayerBuilder>(
215  cfg, makeActsAthenaLogger(this, std::string("PixelGMSLayBldr"), std::string("ActsTGSvc")));
216  Acts::CylinderVolumeBuilder::Config cvbConfig;
217  cvbConfig.layerEnvelopeR = {3_mm, 3_mm};
218  cvbConfig.layerEnvelopeZ = 1_mm;
219  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
220  cvbConfig.volumeName = "Pixel";
221  cvbConfig.layerBuilder = lb;
222  cvbConfig.buildToRadiusZero = !m_buildBeamPipe;
223 
224  Acts::CylinderVolumeBuilder cvb(
225  cvbConfig, makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
226 
227  return cvb.trackingVolume(gctx, inner);
228  });
229  }
230 
231  // ITK PIXEL
232  if (buildSubdet.count("ITkPixel") > 0) {
233  tgbConfig.trackingVolumeBuilders.push_back(
234  [&](const auto &gctx, const auto &inner, const auto &) {
235  auto cfg = makeLayerBuilderConfig(p_ITkPixelManager);
236  cfg.mode = ActsLayerBuilder::Mode::ITkPixelInner;
237  cfg.objDebugOutput = m_objDebugOutput;
238  cfg.doEndcapLayerMerging = true;
239  cfg.passiveBarrelLayerRadii = m_passiveITkInnerPixelBarrelLayerRadii;
240  cfg.passiveBarrelLayerHalflengthZ = m_passiveITkInnerPixelBarrelLayerHalflengthZ;
241  cfg.passiveBarrelLayerThickness = m_passiveITkInnerPixelBarrelLayerThickness;
242  auto lb = std::make_shared<ActsLayerBuilder>(
243  cfg, makeActsAthenaLogger(this, std::string("ITkPxInLb"), std::string("ActsTGSvc")));
244 
245  Acts::CylinderVolumeBuilder::Config cvbConfig;
246  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
247  cvbConfig.layerEnvelopeZ = 1_mm;
248  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
249  cvbConfig.volumeName = "ITkPixelInner";
250  cvbConfig.layerBuilder = lb;
251  cvbConfig.buildToRadiusZero = !m_buildBeamPipe;
252 
253  Acts::CylinderVolumeBuilder cvb(
254  cvbConfig,
255  makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
256 
257  return cvb.trackingVolume(gctx, inner);
258  });
259 
260  tgbConfig.trackingVolumeBuilders.push_back(
261  [&](const auto &gctx, const auto &inner, const auto &) {
262  auto cfg = makeLayerBuilderConfig(p_ITkPixelManager);
263  cfg.mode = ActsLayerBuilder::Mode::ITkPixelOuter;
264  cfg.objDebugOutput = m_objDebugOutput;
265  cfg.doEndcapLayerMerging = false;
266  cfg.passiveBarrelLayerRadii = m_passiveITkOuterPixelBarrelLayerRadii;
267  cfg.passiveBarrelLayerHalflengthZ = m_passiveITkOuterPixelBarrelLayerHalflengthZ;
268  cfg.passiveBarrelLayerThickness = m_passiveITkOuterPixelBarrelLayerThickness;
269  auto lb = std::make_shared<ActsLayerBuilder>(
270  cfg, makeActsAthenaLogger(this, std::string("ITkPxOtLb"), std::string("ActsTGSvc")));
271 
272  Acts::CylinderVolumeBuilder::Config cvbConfig;
273  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
274  cvbConfig.layerEnvelopeZ = 1_mm;
275  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
276  cvbConfig.volumeName = "ITkPixelOuter";
277  cvbConfig.layerBuilder = lb;
278  cvbConfig.buildToRadiusZero = false;
279  cvbConfig.checkRingLayout = true;
280  cvbConfig.ringTolerance = 10_mm;
281 
282  Acts::CylinderVolumeBuilder cvb(
283  cvbConfig,
284  makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
285 
286  return cvb.trackingVolume(gctx, inner);
287  });
288  }
289 
290  // ITK STRIP
291  if (buildSubdet.count("ITkStrip") > 0) {
292  tgbConfig.trackingVolumeBuilders.push_back(
293  [&](const auto &gctx, const auto &inner, const auto &) {
294  auto cfg = makeLayerBuilderConfig(p_ITkStripManager);
295  cfg.mode = ActsLayerBuilder::Mode::ITkStrip;
296  cfg.objDebugOutput = m_objDebugOutput;
297  cfg.passiveBarrelLayerRadii = m_passiveITkStripBarrelLayerRadii;
298  cfg.passiveBarrelLayerHalflengthZ = m_passiveITkStripBarrelLayerHalflengthZ;
299  cfg.passiveBarrelLayerThickness = m_passiveITkStripBarrelLayerThickness;
300  auto lb = std::make_shared<ActsLayerBuilder>(
301  cfg, makeActsAthenaLogger(this, std::string("ITkStripLB"), std::string("ActsTGSvc")));
302 
303  Acts::CylinderVolumeBuilder::Config cvbConfig;
304  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
305  cvbConfig.layerEnvelopeZ = 1_mm;
306  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
307  cvbConfig.volumeName = "ITkStrip";
308  cvbConfig.layerBuilder = lb;
309  cvbConfig.buildToRadiusZero =
310  buildSubdet.count("ITkPixel") == 0 && !m_buildBeamPipe;
311 
312  Acts::CylinderVolumeBuilder cvb(
313  cvbConfig,
314  makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
315 
316  return cvb.trackingVolume(gctx, inner);
317  });
318  }
319 
320  bool buildSCT = buildSubdet.count("SCT") > 0;
321  bool buildTRT = buildSubdet.count("TRT") > 0;
322 
323  if (buildSCT && buildTRT) {
324  // building both we need to take care
325  tgbConfig.trackingVolumeBuilders.push_back(
326  [&](const auto &gctx, const auto &inner, const auto &) {
327  auto cfg = makeLayerBuilderConfig(p_SCTManager);
328  cfg.mode = ActsLayerBuilder::Mode::SCT;
329  cfg.endcapEnvelopeZ = sctECEnvelopeZ;
330  auto sct_lb = std::make_shared<ActsLayerBuilder>(
331  cfg, makeActsAthenaLogger(this, std::string("SCTGMSLayBldr"), std::string("ActsTGSvc")));
332 
333  auto trt_lb = makeStrawLayerBuilder(p_TRTManager);
334 
335  return makeSCTTRTAssembly(gctx, *sct_lb, *trt_lb,
336  *cylinderVolumeHelper, inner);
337  });
338 
339  } else if (buildSCT) {
340  tgbConfig.trackingVolumeBuilders.push_back(
341  [&](const auto &gctx, const auto &inner, const auto &) {
342  auto lbCfg = makeLayerBuilderConfig(p_SCTManager);
343  lbCfg.mode = ActsLayerBuilder::Mode::SCT;
344  lbCfg.endcapEnvelopeZ = sctECEnvelopeZ;
345  auto lb = std::make_shared<ActsLayerBuilder>(
346  lbCfg,
347  makeActsAthenaLogger(this, std::string("SCTGMSLayBldr"), std::string("ActsTGSvc")));
348 
349  Acts::CylinderVolumeBuilder::Config cvbConfig;
350  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
351  cvbConfig.layerEnvelopeZ = 2_mm;
352  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
353  cvbConfig.volumeName = "SCT";
354  cvbConfig.layerBuilder = lb;
355  cvbConfig.buildToRadiusZero = false;
356 
357  Acts::CylinderVolumeBuilder cvb(
358  cvbConfig,
359  makeActsAthenaLogger(this, std::string("SCTCylVolBldr"), std::string("ActsTGSvc")));
360 
361  return cvb.trackingVolume(gctx, inner);
362  });
363  } else if (buildTRT) {
364  tgbConfig.trackingVolumeBuilders.push_back(
365  [&](const auto &gctx, const auto &inner, const auto &) {
366  auto lb = makeStrawLayerBuilder(p_TRTManager);
367  Acts::CylinderVolumeBuilder::Config cvbConfig;
368  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
369  cvbConfig.layerEnvelopeZ = 2_mm;
370  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
371  cvbConfig.volumeName = "TRT";
372  cvbConfig.layerBuilder = lb;
373  cvbConfig.buildToRadiusZero = false;
374 
375  Acts::CylinderVolumeBuilder cvb(
376  cvbConfig,
377  makeActsAthenaLogger(this, std::string("TRTCylVolBldr"), std::string("ActsTGSvc")));
378 
379  return cvb.trackingVolume(gctx, inner);
380  });
381  }
382 
383  //HGTD
384  if(buildSubdet.count("HGTD") > 0) {
385  tgbConfig.trackingVolumeBuilders.push_back(
386  [&](const auto &gctx, const auto &inner, const auto &) {
387  auto lb = makeHGTDLayerBuilder(p_HGTDManager); //using ActsHGTDLayerBuilder
388  Acts::CylinderVolumeBuilder::Config cvbConfig;
389  cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
390  cvbConfig.layerEnvelopeZ = 1_mm;
391  cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
392  cvbConfig.volumeName = "HGTD";
393  cvbConfig.layerBuilder = lb;
394  cvbConfig.buildToRadiusZero = false;
395 
396  Acts::CylinderVolumeBuilder cvb(
397  cvbConfig,
398  makeActsAthenaLogger(this, std::string("HGTDCylVolBldr"), std::string("ActsTGSvc")));
399 
400  return cvb.trackingVolume(gctx, inner);
401  });
402  }
403 
404  // Calo
405  if (buildSubdet.count("Calo") > 0) {
406  tgbConfig.trackingVolumeBuilders.push_back(
407  [&](const auto &gctx, const auto &inner, const auto &) {
408  return m_caloVolumeBuilder->trackingVolume(gctx, inner, nullptr);
409  });
410  }
411 
412  if (buildSubdet.count("Muon")){
413  tgbConfig.trackingVolumeBuilders.push_back(
414  [&](const auto &gctx, const auto &inner, const auto &) {
415  return m_msVolumeBuilder->trackingVolume(gctx, inner, nullptr);
416  });
417  }
418  } catch (const std::exception &e) {
419  ATH_MSG_ERROR("Encountered error when building Acts tracking geometry");
420  ATH_MSG_ERROR(e.what());
421  return StatusCode::FAILURE;
422  }
423 
424  auto trackingGeometryBuilder =
425  std::make_shared<const Acts::TrackingGeometryBuilder>(
426  tgbConfig, makeActsAthenaLogger(this, std::string("TrkGeomBldr"), std::string("ActsTGSvc")));
427 
428  ATH_MSG_VERBOSE("Begin building process");
429  m_trackingGeometry =
430  trackingGeometryBuilder->trackingGeometry(getNominalContext().context());
431  ATH_MSG_VERBOSE("Building process completed");
432 
433  if (!m_trackingGeometry) {
434  ATH_MSG_ERROR("No ACTS tracking geometry was built. Cannot proceeed");
435  return StatusCode::FAILURE;
436  }
437 
438 
439  if(m_runConsistencyChecks) {
440  ATH_MSG_INFO("Running extra consistency check! (this is SLOW)");
441  if(!runConsistencyChecks()) {
442  ATH_MSG_ERROR("Consistency check has failed! Geometry is not consistent");
443  return StatusCode::FAILURE;
444  }
445  }
446 
447  ATH_MSG_INFO("Acts TrackingGeometry construction completed");
448 
449  return StatusCode::SUCCESS;
450 }

◆ makeBeamPipeConfig()

Acts::CylinderVolumeBuilder::Config ActsTrackingGeometrySvc::makeBeamPipeConfig ( std::shared_ptr< const Acts::CylinderVolumeHelper >  cvh) const
private

Definition at line 1064 of file ActsTrackingGeometrySvc.cxx.

1065  {
1066 
1067  // adapted from InnerDetector/InDetDetDescr/InDetTrackingGeometry/src/BeamPipeBuilder.cxx
1068 
1069  PVConstLink beamPipeTopVolume = p_beamPipeMgr->getTreeTop(0);
1070 
1071  if (p_beamPipeMgr->getNumTreeTops() == 1){
1072  beamPipeTopVolume = p_beamPipeMgr->getTreeTop(0)->getChildVol(0)->getChildVol(0);
1073  }
1074 
1075  Acts::Transform3 beamPipeTransform;
1076  beamPipeTransform.setIdentity();
1077 
1078  beamPipeTransform = Acts::Translation3(beamPipeTopVolume->getX().translation());
1079 
1080  double beamPipeRadius = 20;
1081 
1082  const GeoLogVol* beamPipeLogVolume = beamPipeTopVolume->getLogVol();
1083  const GeoTube* beamPipeTube = nullptr;
1084 
1085 
1086  if (beamPipeLogVolume == nullptr) {
1087  ATH_MSG_ERROR("Beam pip volume has no log volume");
1088  throw std::runtime_error("Beam pip volume has no log volume");
1089  }
1090  // get the geoShape and translate
1091  beamPipeTube = dynamic_cast<const GeoTube*>(beamPipeLogVolume->getShape());
1092  if (beamPipeTube == nullptr){
1093  ATH_MSG_ERROR("BeamPipeLogVolume was not of type GeoTube");
1094  throw std::runtime_error{"BeamPipeLogVolume was not of type GeoTube"};
1095  }
1096 
1097  for(unsigned int i=0;i<beamPipeTopVolume->getNChildVols();i++) {
1098 
1099  if(beamPipeTopVolume->getNameOfChildVol(i) == "SectionC03"){
1100 
1101  PVConstLink childTopVolume = beamPipeTopVolume->getChildVol(i);
1102  const GeoLogVol* childLogVolume = childTopVolume->getLogVol();
1103  const GeoTube* childTube = nullptr;
1104 
1105  if (childLogVolume){
1106  childTube = dynamic_cast<const GeoTube*>(childLogVolume->getShape());
1107  if (childTube){
1108  beamPipeRadius = 0.5 * (childTube->getRMax()+childTube->getRMin());
1109  }
1110  }
1111 
1112  break; // Exit loop after SectionC03 is found
1113  }
1114 
1115  } // Loop over child volumes
1116 
1117  ATH_MSG_VERBOSE("BeamPipe constructed from Database: translation (yes) - radius "
1118  << ( beamPipeTube ? "(yes)" : "(no)") << " - r = " << beamPipeRadius );
1119 
1120  ATH_MSG_VERBOSE("BeamPipe shift estimated as : " << Amg::toString(beamPipeTransform.translation()));
1121 
1122  Acts::CylinderVolumeBuilder::Config cfg;
1123 
1124  Acts::PassiveLayerBuilder::Config bplConfig;
1125  bplConfig.layerIdentification = "BeamPipe";
1126  bplConfig.centralLayerRadii = {beamPipeRadius * 1_mm};
1127  bplConfig.centralLayerHalflengthZ = {3000_mm};
1128  bplConfig.centralLayerThickness = {1_mm};
1129  auto beamPipeBuilder = std::make_shared<const Acts::PassiveLayerBuilder>(
1130  bplConfig, makeActsAthenaLogger(this, std::string("BPLayBldr"), std::string("ActsTGSvc")));
1131 
1132  // create the volume for the beam pipe
1133  cfg.trackingVolumeHelper = cvh;
1134  cfg.volumeName = "BeamPipe";
1135  cfg.layerBuilder = beamPipeBuilder;
1136  cfg.layerEnvelopeR = {1_mm, 1_mm};
1137  cfg.buildToRadiusZero = true;
1138 
1139  return cfg;
1140 }

◆ makeHGTDLayerBuilder()

std::shared_ptr< const Acts::ILayerBuilder > ActsTrackingGeometrySvc::makeHGTDLayerBuilder ( const HGTD_DetectorManager *  manager)
private

Definition at line 717 of file ActsTrackingGeometrySvc.cxx.

718  {
719 
720  std::string managerName = manager->getName();
721  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
722  Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
723  const Acts::Surface *
724  /*bS*/) -> bool { return false; };
725 
726  Acts::SurfaceArrayCreator::Config sacCfg;
727  sacCfg.surfaceMatcher = matcher;
728  sacCfg.doPhiBinningOptimization = false;
729 
730  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
731  sacCfg,
732  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
733  Acts::LayerCreator::Config lcCfg;
734  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
735  auto layerCreator = std::make_shared<Acts::LayerCreator>(
736  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
737 
738  ActsHGTDLayerBuilder::Config cfg;
739  cfg.mng = static_cast<const HGTD_DetectorManager *>(manager);
740  cfg.elementStore = m_elementStore;
741  cfg.layerCreator = layerCreator;
742  cfg.idHelper = m_HGTD_idHelper;
743  return std::make_shared<const ActsHGTDLayerBuilder>(
744  cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
745 }

◆ makeLayerBuilderConfig()

ActsLayerBuilder::Config ActsTrackingGeometrySvc::makeLayerBuilderConfig ( const InDetDD::InDetDetectorManager *  manager)
private

Definition at line 747 of file ActsTrackingGeometrySvc.cxx.

748  {
749  using enum Acts::AxisDirection;
750 
751  std::string managerName = manager->getName();
752 
753  std::shared_ptr<const Acts::ILayerBuilder> gmLayerBuilder;
754  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
755  Acts::AxisDirection aDir, const Acts::Surface *aS,
756  const Acts::Surface *bS) -> bool {
757  auto a = dynamic_cast<const ActsDetectorElement *>(
758  aS->associatedDetectorElement());
759  auto b = dynamic_cast<const ActsDetectorElement *>(
760  bS->associatedDetectorElement());
761  if ((not a) or (not b)) {
762  throw std::runtime_error(
763  "Cast of surface associated element to ActsDetectorElement failed "
764  "in ActsTrackingGeometrySvc::makeVolumeBuilder");
765  }
766 
767  IdentityHelper idA = a->identityHelper();
768  IdentityHelper idB = b->identityHelper();
769 
770  // check if same bec
771  // can't be same if not
772  if (idA.bec() != idB.bec())
773  return false;
774 
775  if (aDir == AxisPhi) {
776  // std::cout << idA.phi_module() << " <-> " << idB.phi_module() <<
777  // std::endl;
778  return idA.phi_module() == idB.phi_module();
779  }
780 
781  if (aDir == AxisZ) {
782  return (idA.eta_module() == idB.eta_module()) &&
783  (idA.layer_disk() == idB.layer_disk()) && (idA.bec() == idB.bec());
784  }
785 
786  if (aDir == AxisR) {
787  return (idA.eta_module() == idB.eta_module()) &&
788  (idA.layer_disk() == idB.layer_disk()) && (idB.bec() == idA.bec());
789  }
790 
791  return false;
792  };
793 
794  Acts::SurfaceArrayCreator::Config sacCfg;
795  sacCfg.surfaceMatcher = matcher;
796 
797  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
798  sacCfg,
799  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
800  Acts::LayerCreator::Config lcCfg;
801  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
802  auto layerCreator = std::make_shared<Acts::LayerCreator>(
803  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
804 
805  ActsLayerBuilder::Config cfg;
806  cfg.surfaceMatcher = matcher;
807 
808  // set bins from configuration
809  if (m_barrelMaterialBins.size() != 2) {
810  throw std::invalid_argument("Number of barrel material bin counts != 2");
811  }
812  std::vector<size_t> brlBins(m_barrelMaterialBins);
813  cfg.barrelMaterialBins = {brlBins.at(0), brlBins.at(1)};
814 
815  if (m_endcapMaterialBins.size() != 2) {
816  throw std::invalid_argument("Number of endcap material bin counts != 2");
817  }
818  std::vector<size_t> ecBins(m_endcapMaterialBins);
819  cfg.endcapMaterialBins = {ecBins.at(0), ecBins.at(1)};
820 
821  cfg.mng = static_cast<const InDetDD::SiDetectorManager *>(manager);
822  // use class member element store
823  cfg.elementStore = m_elementStore;
824  cfg.layerCreator = layerCreator;
825 
826  // gmLayerBuilder = std::make_shared<const ActsLayerBuilder>(
827  // cfg, makeActsAthenaLogger(this, managerName + "GMLayBldr",
828  // "ActsTGSvc"));
829 
830  // return gmLayerBuilder;
831  return cfg;
832 }

◆ makeSCTTRTAssembly()

std::shared_ptr< Acts::TrackingVolume > ActsTrackingGeometrySvc::makeSCTTRTAssembly ( const Acts::GeometryContext &  gctx,
const Acts::ILayerBuilder &  sct_lb,
const Acts::ILayerBuilder &  trt_lb,
const Acts::CylinderVolumeHelper &  cvh,
const std::shared_ptr< const Acts::TrackingVolume > &  pixel 
)
private

Definition at line 835 of file ActsTrackingGeometrySvc.cxx.

838  {
839  ATH_MSG_VERBOSE("Building SCT+TRT assembly");
840 
841  Acts::CylinderVolumeBuilder::Config cvbCfg;
842  Acts::CylinderVolumeBuilder cvb(
843  cvbCfg, makeActsAthenaLogger(this, std::string("SCTTRTCVB"), std::string("ActsTGSvc")));
844 
845  ATH_MSG_VERBOSE("Making SCT negative layers: ");
846  Acts::VolumeConfig sctNegEC =
847  cvb.analyzeContent(gctx, sct_lb.negativeLayers(gctx), {});
848  ATH_MSG_VERBOSE("Making SCT positive layers: ");
849  Acts::VolumeConfig sctPosEC =
850  cvb.analyzeContent(gctx, sct_lb.positiveLayers(gctx), {});
851  ATH_MSG_VERBOSE("Making SCT central layers: ");
852  Acts::VolumeConfig sctBrl =
853  cvb.analyzeContent(gctx, sct_lb.centralLayers(gctx), {});
854 
855  ATH_MSG_VERBOSE("Making TRT negative layers: ");
856  Acts::VolumeConfig trtNegEC =
857  cvb.analyzeContent(gctx, trt_lb.negativeLayers(gctx), {});
858  ATH_MSG_VERBOSE("Making TRT positive layers: ");
859  Acts::VolumeConfig trtPosEC =
860  cvb.analyzeContent(gctx, trt_lb.positiveLayers(gctx), {});
861  ATH_MSG_VERBOSE("Making TRT central layers: ");
862  Acts::VolumeConfig trtBrl =
863  cvb.analyzeContent(gctx, trt_lb.centralLayers(gctx), {});
864 
865  // synchronize trt
866 
867  double absZMinEC = std::min(std::abs(trtNegEC.zMax), std::abs(trtPosEC.zMin));
868  double absZMaxEC = std::max(std::abs(trtNegEC.zMin), std::abs(trtPosEC.zMax));
869 
870  trtNegEC.zMin = -absZMaxEC;
871  trtNegEC.zMax = -absZMinEC;
872  trtPosEC.zMin = absZMinEC;
873  trtPosEC.zMax = absZMaxEC;
874 
875  using CVBBV = Acts::CylinderVolumeBounds::BoundValues;
876 
877  // if pixel is present, shrink SCT volumes in R
878  bool isSCTSmallerInZ = false;
879  if (pixel) {
880  ATH_MSG_VERBOSE("Shrinking SCT in R (and maybe in increase size in Z) to fit around Pixel");
881  auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
882  &pixel->volumeBounds());
883  double sctNegECzMin = std::min(sctNegEC.zMin, -pixelBounds->get(CVBBV::eHalfLengthZ));
884  double sctPosECzMax = std::max(sctPosEC.zMax, pixelBounds->get(CVBBV::eHalfLengthZ));
885 
886  ATH_MSG_VERBOSE("- SCT +-EC.rMin: " << sctNegEC.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
887  ATH_MSG_VERBOSE("- SCT BRL.rMin: " << sctBrl.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
888  ATH_MSG_VERBOSE("- SCT EC.zMin: " << sctNegEC.zMin << " -> " << sctNegECzMin);
889  ATH_MSG_VERBOSE("- SCT EC.zMax: " << sctPosEC.zMax << " -> " << sctPosECzMax);
890 
891  sctNegEC.rMin = pixelBounds->get(CVBBV::eMaxR);
892  sctPosEC.rMin = pixelBounds->get(CVBBV::eMaxR);
893  sctBrl.rMin = pixelBounds->get(CVBBV::eMaxR);
894 
895  isSCTSmallerInZ = sctPosEC.zMax < pixelBounds->get(CVBBV::eHalfLengthZ);
896 
897  sctNegEC.zMin = sctNegECzMin;
898  sctPosEC.zMax = sctPosECzMax;
899 
900 
901  } else {
902  ATH_MSG_VERBOSE("Pixel is not configured, not wrapping");
903  }
904 
905  ATH_MSG_VERBOSE("SCT Volume Configuration:");
906  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
907  << " layers, "
908  << sctNegEC.toString());
909  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
910  << sctBrl.toString());
911  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
912  << " layers, "
913  << sctPosEC.toString());
914 
915  ATH_MSG_VERBOSE("TRT Volume Configuration:");
916  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
917  << " layers, "
918  << trtNegEC.toString());
919  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
920  << trtBrl.toString());
921  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
922  << " layers, "
923  << trtPosEC.toString());
924 
925  // harmonize SCT BRL <-> EC, normally the CVB does this, but we're skipping
926  // that
927  sctBrl.zMax = (sctBrl.zMax + sctPosEC.zMin) / 2.;
928  sctBrl.zMin = -sctBrl.zMax;
929 
930  // and now harmonize everything
931  // inflate TRT Barrel to match SCT
932  trtBrl.zMin = sctBrl.zMin;
933  trtBrl.zMax = sctBrl.zMax;
934 
935  // extend TRT endcaps outwards z so they match SCT
936  trtNegEC.zMin = sctNegEC.zMin;
937  trtPosEC.zMax = sctPosEC.zMax;
938 
939  // extend endcap in z so it touches barrel
940  trtNegEC.zMax = trtBrl.zMin;
941  sctNegEC.zMax = trtBrl.zMin;
942  trtPosEC.zMin = trtBrl.zMax;
943  sctPosEC.zMin = trtBrl.zMax;
944 
945  // extend SCT in R so they touch TRT barel
946  sctBrl.rMax = trtBrl.rMin;
947  sctNegEC.rMax = trtNegEC.rMin;
948  sctPosEC.rMax = trtPosEC.rMin;
949 
950  // extend TRT endcaps in r to that of Barrel
951  trtNegEC.rMax = trtBrl.rMax;
952  trtPosEC.rMax = trtBrl.rMax;
953 
954  ATH_MSG_VERBOSE("Dimensions after synchronization between SCT and TRT");
955  ATH_MSG_VERBOSE("SCT Volume Configuration:");
956  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
957  << " layers, "
958  << sctNegEC.toString());
959  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
960  << sctBrl.toString());
961  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
962  << " layers, "
963  << sctPosEC.toString());
964 
965  ATH_MSG_VERBOSE("TRT Volume Configuration:");
966  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
967  << " layers, "
968  << trtNegEC.toString());
969  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
970  << trtBrl.toString());
971  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
972  << " layers, "
973  << trtPosEC.toString());
974 
975  auto makeTVol = [&](const auto &vConf, const auto &name) {
976  return cvh.createTrackingVolume(gctx, vConf.layers, {},
977  nullptr, // no material
978  vConf.rMin, vConf.rMax, vConf.zMin,
979  vConf.zMax, name);
980  };
981 
982  // now turn them into actual TrackingVolumes
983  auto tvSctNegEC = makeTVol(sctNegEC, "SCT::NegativeEndcap");
984  auto tvSctBrl = makeTVol(sctBrl, "SCT::Barrel");
985  auto tvSctPosEC = makeTVol(sctPosEC, "SCT::PositiveEndcap");
986 
987  auto tvTrtNegEC = makeTVol(trtNegEC, "TRT::NegativeEndcap");
988  auto tvTrtBrl = makeTVol(trtBrl, "TRT::Barrel");
989  auto tvTrtPosEC = makeTVol(trtPosEC, "TRT::PositiveEndcap");
990 
991  // combine the endcaps and the barrels, respetively
992  auto negEC =
993  cvh.createContainerTrackingVolume(gctx, {tvSctNegEC, tvTrtNegEC});
994  auto posEC =
995  cvh.createContainerTrackingVolume(gctx, {tvSctPosEC, tvTrtPosEC});
996  auto barrel = cvh.createContainerTrackingVolume(gctx, {tvSctBrl, tvTrtBrl});
997 
998  // and now combine all of those into one container for the assembly
999 
1000  auto container =
1001  cvh.createContainerTrackingVolume(gctx, {negEC, barrel, posEC});
1002 
1003  // if pixel is present, add positive and negative gap volumes so we can wrap
1004  // it all
1005  if (pixel) {
1006  auto containerBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
1007  &container->volumeBounds());
1008  auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
1009  &pixel->volumeBounds());
1010  std::vector<std::shared_ptr<Acts::TrackingVolume>> noVolumes;
1011 
1012  if(!isSCTSmallerInZ) {
1013  // pixel is smaller in z, need gap volumes
1014  auto posGap = cvh.createGapTrackingVolume(
1015  gctx, noVolumes,
1016  nullptr, // no material,
1017  pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
1018  pixelBounds->get(CVBBV::eHalfLengthZ),
1019  containerBounds->get(CVBBV::eHalfLengthZ),
1020  0, // material layers,
1021  true, // cylinder
1022  "Pixel::PositiveGap");
1023  auto negGap = cvh.createGapTrackingVolume(
1024  gctx, noVolumes,
1025  nullptr, // no material,
1026  pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
1027  -containerBounds->get(CVBBV::eHalfLengthZ),
1028  -pixelBounds->get(CVBBV::eHalfLengthZ),
1029  0, // material layers,
1030  true, // cylinder
1031  "Pixel::NegativeGap");
1032 
1033  auto pixelContainer =
1034  cvh.createContainerTrackingVolume(gctx, {negGap, pixel, posGap});
1035  // and now create one container that contains Pixel+SCT+TRT
1036  container =
1037  cvh.createContainerTrackingVolume(gctx, {pixelContainer, container});
1038  }
1039  else {
1040  // wrap the pixel directly
1041  container =
1042  cvh.createContainerTrackingVolume(gctx, {pixel, container});
1043  }
1044 
1045  }
1046 
1047  return container;
1048 }

◆ makeStrawLayerBuilder()

std::shared_ptr< const Acts::ILayerBuilder > ActsTrackingGeometrySvc::makeStrawLayerBuilder ( const InDetDD::InDetDetectorManager *  manager)
private

Definition at line 686 of file ActsTrackingGeometrySvc.cxx.

687  {
688 
689  std::string managerName = manager->getName();
690  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
691  Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
692  const Acts::Surface *
693  /*bS*/) -> bool { return false; };
694 
695  Acts::SurfaceArrayCreator::Config sacCfg;
696  sacCfg.surfaceMatcher = matcher;
697  sacCfg.doPhiBinningOptimization = false;
698 
699  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
700  sacCfg,
701  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
702  Acts::LayerCreator::Config lcCfg;
703  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
704  auto layerCreator = std::make_shared<Acts::LayerCreator>(
705  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
706 
707  ActsStrawLayerBuilder::Config cfg;
708  cfg.mng = static_cast<const InDetDD::TRT_DetectorManager *>(manager);
709  cfg.elementStore = m_elementStore;
710  cfg.layerCreator = layerCreator;
711  cfg.idHelper = m_TRT_idHelper;
712  return std::make_shared<const ActsStrawLayerBuilder>(
713  cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
714 }

◆ populateAlignmentStore()

unsigned int ActsTrackingGeometrySvc::populateAlignmentStore ( ActsTrk::DetectorAlignStore &  store) const
override

Definition at line 1050 of file ActsTrackingGeometrySvc.cxx.

1050  {
1051  ATH_MSG_DEBUG("Populate the alignment store with all detector elements");
1052  unsigned int nElements = 0;
1053  m_trackingGeometry->visitSurfaces([&store, &nElements](const Acts::Surface *srf) {
1054  const Acts::DetectorElementBase *detElem = srf->associatedDetectorElement();
1055  const IDetectorElement *gmde = dynamic_cast<const IDetectorElement *>(detElem);
1056  nElements += gmde->storeAlignedTransforms(store);
1057  });
1058  ATH_MSG_DEBUG("Populated with " << nElements << " elements");
1059  return nElements;
1060 }

◆ runConsistencyChecks()

bool ActsTrackingGeometrySvc::runConsistencyChecks ( ) const
private

Definition at line 452 of file ActsTrackingGeometrySvc.cxx.

452  {
453  bool result = true;
454 
455  std::vector<Acts::Vector2> localPoints;
456  localPoints.reserve(m_consistencyCheckPoints);
457  std::mt19937 gen;
458  std::uniform_real_distribution<> dist(0.0, 1.0);
459 
460  std::optional<std::ofstream> os;
461  if(!m_consistencyCheckOutput.empty()){
462  os = std::ofstream{m_consistencyCheckOutput};
463  if(!os->good()) {
464  throw std::runtime_error{"Failed to open consistency check output file"};
465  }
466  }
467 
468  if(os) {
469  (*os) << "geo_id,vol_id,lay_id,sen_id,type,acts_loc0,acts_loc1,acts_inside,trk_loc0,trk_loc1,trk_inside,x,y,z,g2l_loc0,g2l_loc1,trk_x,trk_y,trk_z" << std::endl;
470  }
471  for(size_t i=0;i<m_consistencyCheckPoints;i++) {
472  localPoints.emplace_back(dist(gen), dist(gen));
473  }
474 
475  Acts::GeometryContext gctx = getNominalContext().context();
476 
477  size_t nTotalSensors = 0;
478  std::array<size_t,3> nInconsistent{0,0,0};
479  size_t nMismatchedCenters = 0;
480  size_t nMismatchedNormals = 0;
481 
482  // Comparison of Eigen vectors, similar to a.isApprox(b), but use absolute comparison to also work with zero vectors.
483  // All values will be mm or radians, so 1e-5 is a reasonable precision.
484  auto isApprox = [](auto& a, auto& b) -> bool {
485  return ((a - b).array().abs() < 1e-5).all();
486  };
487 
488  m_trackingGeometry->visitSurfaces([&](const Acts::Surface *surface) {
489  nTotalSensors++;
490 
491  const auto* actsDetElem = dynamic_cast<const ActsDetectorElement*>(surface->associatedDetectorElement());
492  if(actsDetElem == nullptr) {
493  ATH_MSG_ERROR("Invalid detector element found");
494  result = false;
495  return;
496  }
497  const auto* siDetElem = dynamic_cast<const InDetDD::SiDetectorElement*>(actsDetElem->upstreamDetectorElement());
498  if(siDetElem == nullptr) {
499  return;
500  }
501 
502  const auto* regSurface = dynamic_cast<const Acts::RegularSurface*>(surface);
503  const auto& trkSurface = siDetElem->surface();
504  if(regSurface == nullptr) {
505  ATH_MSG_ERROR("Invalid surface found");
506  result = false;
507  return;
508  }
509 
510  Acts::Vector3 center{regSurface->center(gctx)};
511  Amg::Vector3D trkCenter{trkSurface.center()};
512  if (/* auto *b = */ dynamic_cast<const Acts::AnnulusBounds *>(&surface->bounds()))
513  {
514  // // Acts::AnnulusBounds defines center() as center of whole disc, so get it from the bounds
515  // Acts::Vector2 locCenter{0.5 * (b->rMin() + b->rMax()), 0.5 * (b->phiMin() + b->phiMax())};
516  // center = surface->localToGlobal(gctx, locCenter, Acts::Vector3::Zero());
517  center.head<2>() = trkCenter.head<2>(); // that doesn't (quite) work for xy, so just pass that check
518  }
519 
520  if(!isApprox(trkCenter, center)) {
521  std::string trkName;
522  if (auto idHelper = siDetElem->getIdHelper())
523  {
524  trkName = idHelper->show_to_string(siDetElem->identify());
525  }
526  ATH_MSG_WARNING("Acts surface "
527  << surface->geometryId()
528  << " center (" << center[0] << ',' << center[1] << ',' << center[2]
529  << ") does not match Trk surface " << trkName
530  << " center (" << trkCenter[0] << ',' << trkCenter[1] << ',' << trkCenter[2] << ')');
531  nMismatchedCenters++;
532  result = false;
533  }
534 
535  const auto* lineSurface = dynamic_cast<const Acts::LineSurface*>(surface);
536  if(lineSurface == nullptr) {
537  Acts::Vector3 norm{regSurface->normal(gctx, regSurface->center(gctx))};
538  Amg::Vector3D trkNorm{trkSurface.normal()};
539  if(!isApprox(trkNorm, norm)) {
540  std::string trkName;
541  if (auto idHelper = siDetElem->getIdHelper())
542  {
543  trkName = idHelper->show_to_string(siDetElem->identify());
544  }
545  ATH_MSG_WARNING("Acts surface "
546  << surface->geometryId()
547  << " normal (" << norm[0] << ',' << norm[1] << ',' << norm[2]
548  << ") does not match Trk surface " << trkName
549  << " normal (" << trkNorm[0] << ',' << trkNorm[1] << ',' << trkNorm[2] << ')');
550  nMismatchedNormals++;
551  result = false;
552  }
553  }
554 
555  auto doPoints = [&](unsigned int type, const Acts::Vector2& loc) -> std::array<bool,3> {
556  Acts::Vector3 glb = surface->localToGlobal(gctx, loc, Acts::Vector3::Zero());
557 
558  Amg::Vector2D locTrk = Amg::Vector2D::Zero();
559  Amg::Vector3D glbTrk = Amg::Vector3D::Zero();
560  Acts::Vector2 locg2l = Acts::Vector2::Zero();
561  bool locg2lOk = false;
562  auto locTrkRes = trkSurface.globalToLocal(glb);
563  if (locTrkRes) {
564  locTrk = locTrkRes.value();
565  glbTrk = trkSurface.localToGlobal(locTrk);
566 
567  auto locg2lRes = surface->globalToLocal(gctx, glbTrk, Acts::Vector3::Zero());
568  if (locg2lRes.ok()) {
569  locg2lOk = true;
570  locg2l = locg2lRes.value();
571  }
572  }
573 
574  auto gId = surface->geometryId();
575  if(os) {
576  (*os) << gId.value()
577  << "," << gId.volume()
578  << "," << gId.layer()
579  << "," << gId.sensitive()
580  << "," << type
581  << "," << loc[0]
582  << "," << loc[1]
583  << "," << surface->insideBounds(loc)
584  << "," << locTrk[0]
585  << "," << locTrk[1]
586  << "," << trkSurface.insideBounds(locTrk)
587  << "," << glb[0]
588  << "," << glb[1]
589  << "," << glb[2]
590  << "," << locg2l[0]
591  << "," << locg2l[1]
592  << "," << glbTrk[0]
593  << "," << glbTrk[1]
594  << "," << glbTrk[2]
595  << std::endl;
596  }
597 
598  return {surface->insideBounds(loc) == trkSurface.insideBounds(locTrk),
599  locg2lOk ? isApprox(loc, locg2l) : true,
600  locTrkRes ? isApprox(glb, glbTrk) : true};
601  };
602 
603 
604  constexpr double envelope = 10.0 * Acts::UnitConstants::mm;
605 
606  std::array<bool,3> allOk{true,true,true};
607  if(const auto* bounds = dynamic_cast<const Acts::PlanarBounds*>(&surface->bounds()); bounds) {
608  ATH_MSG_VERBOSE("Planar bounds");
609 
610  const Acts::RectangleBounds& boundingBox = bounds->boundingBox();
611  Acts::Vector2 min = boundingBox.min().array() - envelope;
612  Acts::Vector2 max = boundingBox.max().array() + envelope;
613  Acts::Vector2 diag = max - min;
614 
615  for(const auto& testPoint : localPoints) {
616  Acts::Vector2 loc = min.array() + (testPoint.array() * diag.array());
617  auto pointOk = doPoints(0, loc);
618  for (size_t i=0; i<pointOk.size(); ++i) {
619  if (!pointOk[i]) {
620  result = false;
621  allOk[i] = false;
622  }
623  }
624  }
625 
626  }
627  else if(const auto* bounds = dynamic_cast<const Acts::AnnulusBounds*>(&surface->bounds()); bounds) {
628  ATH_MSG_VERBOSE("Annulus bounds");
629 
630  // custom bounding box algo
631  std::vector<Acts::Vector2> vertices = bounds->vertices(5); // 5 segments on the radial edges
632  Acts::Vector2 min{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
633  Acts::Vector2 max{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest()};
634  for (const auto& vtx : vertices) {
635  min = min.array().min(vtx.array());
636  max = max.array().max(vtx.array());
637  }
638  min.array() -= envelope;
639  max.array() += envelope;
640  Acts::Vector2 diag = max - min;
641 
642  for(const auto& testPoint : localPoints) {
643  Acts::Vector2 locXY = min.array() + (testPoint.array() * diag.array());
644  Acts::Vector2 locPC = dynamic_cast<const Acts::DiscSurface&>(*surface).localCartesianToPolar(locXY);
645 
646  auto pointOk = doPoints(1, locPC);
647  for (size_t i=0; i<pointOk.size(); ++i) {
648  if (!pointOk[i]) {
649  result = false;
650  allOk[i] = false;
651  }
652  }
653  }
654 
655  }
656  else {
657  result = false;
658  }
659 
660  for (size_t i=0; i<allOk.size(); ++i) {
661  if (!allOk[i]) {
662  ++nInconsistent[i];
663  }
664  }
665 
666  });
667 
668  ATH_MSG_INFO("Total number of sensors : " << nTotalSensors);
669  ATH_MSG_INFO("Number of sensors with mismatched centers : " << nMismatchedCenters);
670  ATH_MSG_INFO("Number of sensors with mismatched normals : " << nMismatchedNormals);
671  ATH_MSG_INFO("Number of sensors with inconsistent inside: " << nInconsistent[0]);
672  ATH_MSG_INFO("Number of sensors with inconsistent g2l : " << nInconsistent[1]);
673  ATH_MSG_INFO("Number of sensors with inconsistent l2g : " << nInconsistent[2]);
674 
675  return result;
676 }

◆ trackingGeometry()

std::shared_ptr< const Acts::TrackingGeometry > ActsTrackingGeometrySvc::trackingGeometry ( )
override

Definition at line 679 of file ActsTrackingGeometrySvc.cxx.

679  {
680 
681  ATH_MSG_VERBOSE("Retrieving tracking geometry");
682  return m_trackingGeometry;
683 }

Member Data Documentation

◆ m_barrelMaterialBins

Gaudi::Property<std::vector<size_t> > ActsTrackingGeometrySvc::m_barrelMaterialBins {this, "BarrelMaterialBins", {10, 10}}
private

Definition at line 108 of file ActsTrackingGeometrySvc.h.

◆ m_buildBeamPipe

Gaudi::Property<bool> ActsTrackingGeometrySvc::m_buildBeamPipe {this, "BuildBeamPipe", false, ""}
private

Definition at line 106 of file ActsTrackingGeometrySvc.h.

◆ m_buildSubdetectors

Gaudi::Property<std::vector<std::string> > ActsTrackingGeometrySvc::m_buildSubdetectors {this, "BuildSubDetectors", {"Pixel", "SCT", "TRT", "Calo", "HGTD", "Muon"}}
private

Definition at line 110 of file ActsTrackingGeometrySvc.h.

◆ m_caloVolumeBuilder

ToolHandle<IActsTrackingVolumeBuilder> ActsTrackingGeometrySvc::m_caloVolumeBuilder
private
Initial value:
{this,
"CaloVolumeBuilder", "", "CaloVolumeBuilder"}

Definition at line 137 of file ActsTrackingGeometrySvc.h.

◆ m_consistencyCheckOutput

StringProperty ActsTrackingGeometrySvc::m_consistencyCheckOutput
private
Initial value:
{this, "ConsistencyCheckOutput",
"", "Output file for geometry debugging, will not write if empty",}

Definition at line 131 of file ActsTrackingGeometrySvc.h.

◆ m_consistencyCheckPoints

Gaudi::Property<size_t> ActsTrackingGeometrySvc::m_consistencyCheckPoints
private
Initial value:
{this, "ConsistencyCheckPoints",
1000, "number of random points for consistency check"}

Definition at line 134 of file ActsTrackingGeometrySvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> ActsTrackingGeometrySvc::m_detStore
private

Definition at line 85 of file ActsTrackingGeometrySvc.h.

◆ m_elementStore

std::shared_ptr<ActsElementVector> ActsTrackingGeometrySvc::m_elementStore {nullptr}
private

Definition at line 94 of file ActsTrackingGeometrySvc.h.

◆ m_endcapMaterialBins

Gaudi::Property<std::vector<size_t> > ActsTrackingGeometrySvc::m_endcapMaterialBins {this, "EndcapMaterialBins", {5, 20}}
private

Definition at line 109 of file ActsTrackingGeometrySvc.h.

◆ m_HGTD_idHelper

const HGTD_ID* ActsTrackingGeometrySvc::m_HGTD_idHelper {nullptr}
private

Definition at line 98 of file ActsTrackingGeometrySvc.h.

◆ m_materialMapCalibFolder

Gaudi::Property<std::string> ActsTrackingGeometrySvc::m_materialMapCalibFolder {this, "MaterialMapCalibFolder", ".", ""}
private

Definition at line 105 of file ActsTrackingGeometrySvc.h.

◆ m_materialMapInputFileBase

Gaudi::Property<std::string> ActsTrackingGeometrySvc::m_materialMapInputFileBase {this, "MaterialMapInputFile", "", ""}
private

Definition at line 104 of file ActsTrackingGeometrySvc.h.

◆ m_msVolumeBuilder

ToolHandle<IActsTrackingVolumeBuilder> ActsTrackingGeometrySvc::m_msVolumeBuilder
private
Initial value:
{this,
"MSVolumeBuilder", "", "MSVolumeBuilder"}

Definition at line 140 of file ActsTrackingGeometrySvc.h.

◆ m_nominalContext

ActsGeometryContext ActsTrackingGeometrySvc::m_nominalContext {}
private

Definition at line 100 of file ActsTrackingGeometrySvc.h.

◆ m_objDebugOutput

Gaudi::Property<bool> ActsTrackingGeometrySvc::m_objDebugOutput {this, "ObjDebugOutput", false, ""}
private

Definition at line 103 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkInnerPixelBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerHalflengthZ {this, "PassiveITkInnerPixelBarrelLayerHalflengthZ", {}}
private

Definition at line 117 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkInnerPixelBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerRadii {this, "PassiveITkInnerPixelBarrelLayerRadii", {}}
private

the specifications for building additional passive cylinders in the barrel region: for each cylinder you want to specify radius, half length in z and thickness

Definition at line 116 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkInnerPixelBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerThickness {this, "PassiveITkInnerPixelBarrelLayerThickness", {}}
private

Definition at line 118 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerHalflengthZ {this, "PassiveITkOuterPixelBarrelLayerHalflengthZ", {}}
private

Definition at line 121 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerRadii {this, "PassiveITkOuterPixelBarrelLayerRadii", {}}
private

Definition at line 120 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerThickness {this, "PassiveITkOuterPixelBarrelLayerThickness", {}}
private

Definition at line 122 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerHalflengthZ {this, "PassiveITkStripBarrelLayerHalflengthZ", {}}
private

Definition at line 125 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerRadii {this, "PassiveITkStripBarrelLayerRadii", {}}
private

Definition at line 124 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerThickness {this, "PassiveITkStripBarrelLayerThickness", {}}
private

Definition at line 126 of file ActsTrackingGeometrySvc.h.

◆ m_runConsistencyChecks

BooleanProperty ActsTrackingGeometrySvc::m_runConsistencyChecks
private
Initial value:
{this, "RunConsistencyChecks",
false, "Run extra consistency checks w.r.t to Trk::. This is SLOW!"}

Definition at line 128 of file ActsTrackingGeometrySvc.h.

◆ m_subDetNoAlign

std::set<ActsTrk::DetectorType> ActsTrackingGeometrySvc::m_subDetNoAlign {}
private

Definition at line 144 of file ActsTrackingGeometrySvc.h.

◆ m_subDetNoAlignProp

Gaudi::Property<std::vector<unsigned int> > ActsTrackingGeometrySvc::m_subDetNoAlignProp {this, "NotAlignDetectors", {}}
private

Define the subdetectors for which the tracking geometry does not expect a valid alignment store.

Definition at line 143 of file ActsTrackingGeometrySvc.h.

◆ m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> ActsTrackingGeometrySvc::m_trackingGeometry {nullptr}
private

Definition at line 95 of file ActsTrackingGeometrySvc.h.

◆ m_TRT_idHelper

const TRT_ID* ActsTrackingGeometrySvc::m_TRT_idHelper {nullptr}
private

Definition at line 97 of file ActsTrackingGeometrySvc.h.

◆ m_useMaterialMap

Gaudi::Property<bool> ActsTrackingGeometrySvc::m_useMaterialMap {this, "UseMaterialMap", false, ""}
private

Definition at line 102 of file ActsTrackingGeometrySvc.h.

◆ p_beamPipeMgr

const BeamPipeDetectorManager* ActsTrackingGeometrySvc::p_beamPipeMgr {nullptr}
private

Definition at line 91 of file ActsTrackingGeometrySvc.h.

◆ p_HGTDManager

const HGTD_DetectorManager* ActsTrackingGeometrySvc::p_HGTDManager {nullptr}
private

Definition at line 92 of file ActsTrackingGeometrySvc.h.

◆ p_ITkPixelManager

const InDetDD::SiDetectorManager* ActsTrackingGeometrySvc::p_ITkPixelManager {nullptr}
private

Definition at line 89 of file ActsTrackingGeometrySvc.h.

◆ p_ITkStripManager

const InDetDD::SiDetectorManager* ActsTrackingGeometrySvc::p_ITkStripManager {nullptr}
private

Definition at line 90 of file ActsTrackingGeometrySvc.h.

◆ p_pixelManager

const InDetDD::SiDetectorManager* ActsTrackingGeometrySvc::p_pixelManager {nullptr}
private

Definition at line 86 of file ActsTrackingGeometrySvc.h.

◆ p_SCTManager

const InDetDD::SiDetectorManager* ActsTrackingGeometrySvc::p_SCTManager {nullptr}
private

Definition at line 87 of file ActsTrackingGeometrySvc.h.

◆ p_TRTManager

const InDetDD::TRT_DetectorManager* ActsTrackingGeometrySvc::p_TRTManager {nullptr}
private

Definition at line 88 of file ActsTrackingGeometrySvc.h.

The documentation for this class was generated from the following files:
ActsTrackingGeometrySvc::makeBeamPipeConfig
Acts::CylinderVolumeBuilder::Config makeBeamPipeConfig(std::shared_ptr< const Acts::CylinderVolumeHelper > cvh) const
Definition: ActsTrackingGeometrySvc.cxx:1064
IdentityHelper::phi_module
int phi_module() const
Definition: IdentityHelper.cxx:61
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
SGTest::store
TestStore store
Definition: TestStore.cxx:23
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrackingGeometrySvc::m_runConsistencyChecks
BooleanProperty m_runConsistencyChecks
Definition: ActsTrackingGeometrySvc.h:128
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:97
ActsLayerBuilder::Mode::ITkPixelOuter
@ ITkPixelOuter
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerHalflengthZ
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerHalflengthZ
Definition: ActsTrackingGeometrySvc.h:125
ActsTrackingGeometrySvc::m_consistencyCheckOutput
StringProperty m_consistencyCheckOutput
Definition: ActsTrackingGeometrySvc.h:131
ActsLayerBuilder::Mode::ITkPixelInner
@ ITkPixelInner
ActsTrk::DetectorType
DetectorType
Simple enum to Identify the Type of the ACTS sub detector.
Definition: GeometryDefs.h:17
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
ActsTrackingGeometrySvc::m_barrelMaterialBins
Gaudi::Property< std::vector< size_t > > m_barrelMaterialBins
Definition: ActsTrackingGeometrySvc.h:108
ActsHGTDLayerBuilder::Config
Definition: ActsHGTDLayerBuilder.h:45
IdentityHelper::layer_disk
int layer_disk() const
Definition: IdentityHelper.cxx:49
BeamPipeDetectorManager::getNumTreeTops
virtual unsigned int getNumTreeTops() const
Definition: BeamPipeDetectorManager.cxx:15
InDetDD::SolidStateDetectorElementBase::surface
Trk::Surface & surface()
Element Surface.
ActsTrackingGeometrySvc::runConsistencyChecks
bool runConsistencyChecks() const
Definition: ActsTrackingGeometrySvc.cxx:452
ActsTrk::actsLevelVector
Acts::Logging::Level actsLevelVector(MSG::Level lvl)
Definition: LoggerUtils.cxx:9
ActsStrawLayerBuilder::Config
Definition: ActsStrawLayerBuilder.h:35
ActsTrackingGeometrySvc::m_consistencyCheckPoints
Gaudi::Property< size_t > m_consistencyCheckPoints
Definition: ActsTrackingGeometrySvc.h:134
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ActsTrackingGeometrySvc::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: ActsTrackingGeometrySvc.h:85
ActsTrackingGeometrySvc::p_ITkPixelManager
const InDetDD::SiDetectorManager * p_ITkPixelManager
Definition: ActsTrackingGeometrySvc.h:89
BeamPipeDetectorManager::getTreeTop
virtual PVConstLink getTreeTop(unsigned int i) const
Definition: BeamPipeDetectorManager.cxx:20
ActsLayerBuilder::Config
Definition: ActsLayerBuilder.h:51
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
ActsTrackingGeometrySvc::p_beamPipeMgr
const BeamPipeDetectorManager * p_beamPipeMgr
Definition: ActsTrackingGeometrySvc.h:91
ActsTrackingGeometrySvc::m_caloVolumeBuilder
ToolHandle< IActsTrackingVolumeBuilder > m_caloVolumeBuilder
Definition: ActsTrackingGeometrySvc.h:137
ActsLayerBuilder::Mode::Pixel
@ Pixel
master.gen
gen
Definition: master.py:32
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
ActsTrackingGeometrySvc::getNominalContext
const ActsGeometryContext & getNominalContext() const override
Definition: ActsTrackingGeometrySvc.cxx:1061
ActsTrackingGeometrySvc::p_TRTManager
const InDetDD::TRT_DetectorManager * p_TRTManager
Definition: ActsTrackingGeometrySvc.h:88
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
ActsTrackingGeometrySvc::p_HGTDManager
const HGTD_DetectorManager * p_HGTDManager
Definition: ActsTrackingGeometrySvc.h:92
ActsTrackingGeometrySvc::m_msVolumeBuilder
ToolHandle< IActsTrackingVolumeBuilder > m_msVolumeBuilder
Definition: ActsTrackingGeometrySvc.h:140
ActsLayerBuilder::Mode::ITkStrip
@ ITkStrip
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:87
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrackingGeometrySvc::m_elementStore
std::shared_ptr< ActsElementVector > m_elementStore
Definition: ActsTrackingGeometrySvc.h:94
ActsTrackingGeometrySvc::m_materialMapInputFileBase
Gaudi::Property< std::string > m_materialMapInputFileBase
Definition: ActsTrackingGeometrySvc.h:104
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ActsTrackingGeometrySvc::p_pixelManager
const InDetDD::SiDetectorManager * p_pixelManager
Definition: ActsTrackingGeometrySvc.h:86
calibdata.exception
exception
Definition: calibdata.py:496
ActsTrackingGeometrySvc::p_SCTManager
const InDetDD::SiDetectorManager * p_SCTManager
Definition: ActsTrackingGeometrySvc.h:87
ActsTrackingGeometrySvc::m_buildBeamPipe
Gaudi::Property< bool > m_buildBeamPipe
Definition: ActsTrackingGeometrySvc.h:106
ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerRadii
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerRadii
Definition: ActsTrackingGeometrySvc.h:124
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerRadii
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerRadii
Definition: ActsTrackingGeometrySvc.h:120
ActsTrackingGeometrySvc::makeLayerBuilderConfig
ActsLayerBuilder::Config makeLayerBuilderConfig(const InDetDD::InDetDetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:747
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsDetectorElement
Definition: ActsDetectorElement.h:42
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
ActsTrk::IDetectorElement
Base class interface for the actual readout elements.
Definition: IDetectorElement.h:43
ActsTrk::IDetectorElement::storeAlignedTransforms
virtual unsigned int storeAlignedTransforms(const ActsTrk::DetectorAlignStore &store) const =0
Caches the aligned transformation in the provided store. Returns the number of cached elements.
ActsTrackingGeometrySvc::m_endcapMaterialBins
Gaudi::Property< std::vector< size_t > > m_endcapMaterialBins
Definition: ActsTrackingGeometrySvc.h:109
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
ActsTrackingGeometrySvc::m_materialMapCalibFolder
Gaudi::Property< std::string > m_materialMapCalibFolder
Definition: ActsTrackingGeometrySvc.h:105
ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:118
IdentityHelper::eta_module
int eta_module() const
Definition: IdentityHelper.cxx:73
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:126
ActsTrackingGeometrySvc::makeSCTTRTAssembly
std::shared_ptr< Acts::TrackingVolume > makeSCTTRTAssembly(const Acts::GeometryContext &gctx, const Acts::ILayerBuilder &sct_lb, const Acts::ILayerBuilder &trt_lb, const Acts::CylinderVolumeHelper &cvh, const std::shared_ptr< const Acts::TrackingVolume > &pixel)
Definition: ActsTrackingGeometrySvc.cxx:835
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ActsTrackingGeometrySvc::p_ITkStripManager
const InDetDD::SiDetectorManager * p_ITkStripManager
Definition: ActsTrackingGeometrySvc.h:90
CVBBV
Acts::CylinderVolumeBounds::BoundValues CVBBV
Definition: ActsCaloTrackingVolumeBuilder.cxx:31
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerHalflengthZ
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerHalflengthZ
Definition: ActsTrackingGeometrySvc.h:121
IdentityHelper::bec
int bec() const
Definition: IdentityHelper.cxx:37
InDetDD::TRT_DetectorManager
The Detector Manager for all TRT Detector elements, it acts as the interface to the detector elements...
Definition: TRT_DetectorManager.h:69
a
TList * a
Definition: liststreamerinfos.cxx:10
ActsTrackingGeometrySvc::m_subDetNoAlign
std::set< ActsTrk::DetectorType > m_subDetNoAlign
Definition: ActsTrackingGeometrySvc.h:144
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:122
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DetectorZone::barrel
@ barrel
InDetDD::SiDetectorManager
Definition: SiDetectorManager.h:60
HGTD_DetectorManager
Definition: HGTD_DetectorManager.h:33
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:146
ActsTrackingGeometrySvc::makeStrawLayerBuilder
std::shared_ptr< const Acts::ILayerBuilder > makeStrawLayerBuilder(const InDetDD::InDetDetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:686
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
ActsTrackingGeometrySvc::m_useMaterialMap
Gaudi::Property< bool > m_useMaterialMap
Definition: ActsTrackingGeometrySvc.h:102
ActsTrackingGeometrySvc::m_trackingGeometry
std::shared_ptr< const Acts::TrackingGeometry > m_trackingGeometry
Definition: ActsTrackingGeometrySvc.h:95
DataPrepToActsConfig.pixelContainer
pixelContainer
Definition: DataPrepToActsConfig.py:9
ActsTrackingGeometrySvc::makeHGTDLayerBuilder
std::shared_ptr< const Acts::ILayerBuilder > makeHGTDLayerBuilder(const HGTD_DetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:717
ActsTrackingGeometrySvc::m_buildSubdetectors
Gaudi::Property< std::vector< std::string > > m_buildSubdetectors
Definition: ActsTrackingGeometrySvc.h:110
IdentityHelper
Definition: IdentityHelper.h:14
ActsTrackingGeometrySvc::m_nominalContext
ActsGeometryContext m_nominalContext
Definition: ActsTrackingGeometrySvc.h:100
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
ActsTrackingGeometrySvc::m_TRT_idHelper
const TRT_ID * m_TRT_idHelper
Definition: ActsTrackingGeometrySvc.h:97
ActsTrackingGeometrySvc::m_HGTD_idHelper
const HGTD_ID * m_HGTD_idHelper
Definition: ActsTrackingGeometrySvc.h:98
ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerRadii
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerRadii
the specifications for building additional passive cylinders in the barrel region: for each cylinder ...
Definition: ActsTrackingGeometrySvc.h:116
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
ActsTrackingGeometrySvc::m_subDetNoAlignProp
Gaudi::Property< std::vector< unsigned int > > m_subDetNoAlignProp
Define the subdetectors for which the tracking geometry does not expect a valid alignment store.
Definition: ActsTrackingGeometrySvc.h:143
ActsTrackingGeometrySvc::m_objDebugOutput
Gaudi::Property< bool > m_objDebugOutput
Definition: ActsTrackingGeometrySvc.h:103
SiliconTech::pixel
@ pixel
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
ActsLayerBuilder::Mode::SCT
@ SCT
ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerHalflengthZ
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerHalflengthZ
Definition: ActsTrackingGeometrySvc.h:117
Generated on Sat May 31 2025 21:25:21 for ATLAS Offline Software by   doxygen 1.8.18