ATLAS Offline Software
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 {this, "CaloVolumeBuilder", ""}
 
ToolHandle< IActsTrackingVolumeBuilder > m_msVolumeBuilder {this, "MSVolumeBuilder", ""}
 
ToolHandleArray< ActsTrk::IBlueprintNodeBuilder > m_blueprintNodeBuilders {this, "BlueprintNodeBuilders", {}}
 
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 {}
 
Gaudi::Property< bool > m_useBlueprint {this, "UseBlueprint", false, "Use the new Blueprint API for geometry construction"}
 
Gaudi::Property< std::string > m_blueprintGraphviz
 
Gaudi::Property< bool > m_doEndcapLayerMerging {this, "DoEndcapLayerMerging", true, "Merge overlapping endcap layers in z"}
 

Detailed Description

Definition at line 55 of file ActsTrackingGeometrySvc.h.

Constructor & Destructor Documentation

◆ ActsTrackingGeometrySvc()

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

Definition at line 69 of file ActsTrackingGeometrySvc.cxx.

71  : base_class(name, svc),
72  m_detStore("StoreGateSvc/DetectorStore", name),
73  m_elementStore (std::make_shared<ActsElementVector>())
74 {
75 }

Member Function Documentation

◆ getNominalContext()

const ActsGeometryContext & ActsTrackingGeometrySvc::getNominalContext ( ) const
override

Definition at line 1134 of file ActsTrackingGeometrySvc.cxx.

1134 { return m_nominalContext; }

◆ initialize()

StatusCode ActsTrackingGeometrySvc::initialize ( )
override

Definition at line 77 of file ActsTrackingGeometrySvc.cxx.

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

◆ makeBeamPipeConfig()

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

Definition at line 1137 of file ActsTrackingGeometrySvc.cxx.

1138  {
1139 
1140  // adapted from InnerDetector/InDetDetDescr/InDetTrackingGeometry/src/BeamPipeBuilder.cxx
1141 
1142  PVConstLink beamPipeTopVolume = p_beamPipeMgr->getTreeTop(0);
1143 
1144  if (p_beamPipeMgr->getNumTreeTops() == 1){
1145  beamPipeTopVolume = p_beamPipeMgr->getTreeTop(0)->getChildVol(0)->getChildVol(0);
1146  }
1147 
1148  Acts::Transform3 beamPipeTransform;
1149  beamPipeTransform.setIdentity();
1150 
1151  beamPipeTransform = Acts::Translation3(beamPipeTopVolume->getX().translation());
1152 
1153  double beamPipeRadius = 20;
1154 
1155  const GeoLogVol* beamPipeLogVolume = beamPipeTopVolume->getLogVol();
1156  const GeoTube* beamPipeTube = nullptr;
1157 
1158 
1159  if (beamPipeLogVolume == nullptr) {
1160  ATH_MSG_ERROR("Beam pip volume has no log volume");
1161  throw std::runtime_error("Beam pip volume has no log volume");
1162  }
1163  // get the geoShape and translate
1164  beamPipeTube = dynamic_cast<const GeoTube*>(beamPipeLogVolume->getShape());
1165  if (beamPipeTube == nullptr){
1166  ATH_MSG_ERROR("BeamPipeLogVolume was not of type GeoTube");
1167  throw std::runtime_error{"BeamPipeLogVolume was not of type GeoTube"};
1168  }
1169 
1170  for(unsigned int i=0;i<beamPipeTopVolume->getNChildVols();i++) {
1171 
1172  if(beamPipeTopVolume->getNameOfChildVol(i) == "SectionC03"){
1173 
1174  PVConstLink childTopVolume = beamPipeTopVolume->getChildVol(i);
1175  const GeoLogVol* childLogVolume = childTopVolume->getLogVol();
1176  const GeoTube* childTube = nullptr;
1177 
1178  if (childLogVolume){
1179  childTube = dynamic_cast<const GeoTube*>(childLogVolume->getShape());
1180  if (childTube){
1181  beamPipeRadius = 0.5 * (childTube->getRMax()+childTube->getRMin());
1182  }
1183  }
1184 
1185  break; // Exit loop after SectionC03 is found
1186  }
1187 
1188  } // Loop over child volumes
1189 
1190  ATH_MSG_VERBOSE("BeamPipe constructed from Database: translation (yes) - radius "
1191  << ( beamPipeTube ? "(yes)" : "(no)") << " - r = " << beamPipeRadius );
1192 
1193  ATH_MSG_VERBOSE("BeamPipe shift estimated as : " << Amg::toString(beamPipeTransform.translation()));
1194 
1195  Acts::CylinderVolumeBuilder::Config cfg;
1196 
1197  Acts::PassiveLayerBuilder::Config bplConfig;
1198  bplConfig.layerIdentification = "BeamPipe";
1199  bplConfig.centralLayerRadii = {beamPipeRadius * 1_mm};
1200  bplConfig.centralLayerHalflengthZ = {3000_mm};
1201  bplConfig.centralLayerThickness = {1_mm};
1202  auto beamPipeBuilder = std::make_shared<const Acts::PassiveLayerBuilder>(
1203  bplConfig, makeActsAthenaLogger(this, std::string("BPLayBldr"), std::string("ActsTGSvc")));
1204 
1205  // create the volume for the beam pipe
1206  cfg.trackingVolumeHelper = cvh;
1207  cfg.volumeName = "BeamPipe";
1208  cfg.layerBuilder = beamPipeBuilder;
1209  cfg.layerEnvelopeR = {1_mm, 1_mm};
1210  cfg.buildToRadiusZero = true;
1211 
1212  return cfg;
1213 }

◆ makeHGTDLayerBuilder()

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

Definition at line 788 of file ActsTrackingGeometrySvc.cxx.

789  {
790 
791  std::string managerName = manager->getName();
792  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
793  Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
794  const Acts::Surface *
795  /*bS*/) -> bool { return false; };
796 
797  Acts::SurfaceArrayCreator::Config sacCfg;
798  sacCfg.surfaceMatcher = matcher;
799  sacCfg.doPhiBinningOptimization = false;
800 
801  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
802  sacCfg,
803  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
804  Acts::LayerCreator::Config lcCfg;
805  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
806  auto layerCreator = std::make_shared<Acts::LayerCreator>(
807  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
808 
809  ActsHGTDLayerBuilder::Config cfg;
810  cfg.mng = static_cast<const HGTD_DetectorManager *>(manager);
811  cfg.elementStore = m_elementStore;
812  cfg.layerCreator = layerCreator;
813  cfg.idHelper = m_HGTD_idHelper;
814  return std::make_shared<const ActsHGTDLayerBuilder>(
815  cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
816 }

◆ makeLayerBuilderConfig()

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

Definition at line 818 of file ActsTrackingGeometrySvc.cxx.

819  {
820  using enum Acts::AxisDirection;
821 
822  std::string managerName = manager->getName();
823 
824  std::shared_ptr<const Acts::ILayerBuilder> gmLayerBuilder;
825  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
826  Acts::AxisDirection aDir, const Acts::Surface *aS,
827  const Acts::Surface *bS) -> bool {
828  auto a = dynamic_cast<const ActsDetectorElement *>(
829  aS->associatedDetectorElement());
830  auto b = dynamic_cast<const ActsDetectorElement *>(
831  bS->associatedDetectorElement());
832  if ((not a) or (not b)) {
833  throw std::runtime_error(
834  "Cast of surface associated element to ActsDetectorElement failed "
835  "in ActsTrackingGeometrySvc::makeVolumeBuilder");
836  }
837 
838  IdentityHelper idA = a->identityHelper();
839  IdentityHelper idB = b->identityHelper();
840 
841  // check if same bec
842  // can't be same if not
843  if (idA.bec() != idB.bec())
844  return false;
845 
846  if (aDir == AxisPhi) {
847  // std::cout << idA.phi_module() << " <-> " << idB.phi_module() <<
848  // std::endl;
849  return idA.phi_module() == idB.phi_module();
850  }
851 
852  if (aDir == AxisZ) {
853  return (idA.eta_module() == idB.eta_module()) &&
854  (idA.layer_disk() == idB.layer_disk()) && (idA.bec() == idB.bec());
855  }
856 
857  if (aDir == AxisR) {
858  return (idA.eta_module() == idB.eta_module()) &&
859  (idA.layer_disk() == idB.layer_disk()) && (idB.bec() == idA.bec());
860  }
861 
862  return false;
863  };
864 
865  Acts::SurfaceArrayCreator::Config sacCfg;
866  sacCfg.surfaceMatcher = matcher;
867 
868  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
869  sacCfg,
870  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
871  Acts::LayerCreator::Config lcCfg;
872  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
873  auto layerCreator = std::make_shared<Acts::LayerCreator>(
874  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
875 
876  ActsLayerBuilder::Config cfg;
877  cfg.surfaceMatcher = matcher;
878 
879  // set bins from configuration
880  if (m_barrelMaterialBins.size() != 2) {
881  throw std::invalid_argument("Number of barrel material bin counts != 2");
882  }
883  std::vector<size_t> brlBins(m_barrelMaterialBins);
884  cfg.barrelMaterialBins = {brlBins.at(0), brlBins.at(1)};
885 
886  if (m_endcapMaterialBins.size() != 2) {
887  throw std::invalid_argument("Number of endcap material bin counts != 2");
888  }
889  std::vector<size_t> ecBins(m_endcapMaterialBins);
890  cfg.endcapMaterialBins = {ecBins.at(0), ecBins.at(1)};
891 
892  cfg.mng = static_cast<const InDetDD::SiDetectorManager *>(manager);
893  // use class member element store
894  cfg.elementStore = m_elementStore;
895  cfg.layerCreator = layerCreator;
896 
897  // gmLayerBuilder = std::make_shared<const ActsLayerBuilder>(
898  // cfg, makeActsAthenaLogger(this, managerName + "GMLayBldr",
899  // "ActsTGSvc"));
900 
901  // return gmLayerBuilder;
902  return cfg;
903 }

◆ 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 906 of file ActsTrackingGeometrySvc.cxx.

909  {
910  ATH_MSG_VERBOSE("Building SCT+TRT assembly");
911 
912  Acts::CylinderVolumeBuilder::Config cvbCfg;
913  Acts::CylinderVolumeBuilder cvb(
914  cvbCfg, makeActsAthenaLogger(this, std::string("SCTTRTCVB"), std::string("ActsTGSvc")));
915 
916  ATH_MSG_VERBOSE("Making SCT negative layers: ");
917  Acts::VolumeConfig sctNegEC =
918  cvb.analyzeContent(gctx, sct_lb.negativeLayers(gctx), {});
919  ATH_MSG_VERBOSE("Making SCT positive layers: ");
920  Acts::VolumeConfig sctPosEC =
921  cvb.analyzeContent(gctx, sct_lb.positiveLayers(gctx), {});
922  ATH_MSG_VERBOSE("Making SCT central layers: ");
923  Acts::VolumeConfig sctBrl =
924  cvb.analyzeContent(gctx, sct_lb.centralLayers(gctx), {});
925 
926  ATH_MSG_VERBOSE("Making TRT negative layers: ");
927  Acts::VolumeConfig trtNegEC =
928  cvb.analyzeContent(gctx, trt_lb.negativeLayers(gctx), {});
929  ATH_MSG_VERBOSE("Making TRT positive layers: ");
930  Acts::VolumeConfig trtPosEC =
931  cvb.analyzeContent(gctx, trt_lb.positiveLayers(gctx), {});
932  ATH_MSG_VERBOSE("Making TRT central layers: ");
933  Acts::VolumeConfig trtBrl =
934  cvb.analyzeContent(gctx, trt_lb.centralLayers(gctx), {});
935 
936  // synchronize trt
937 
938  double absZMinEC = std::min(std::abs(trtNegEC.zMax), std::abs(trtPosEC.zMin));
939  double absZMaxEC = std::max(std::abs(trtNegEC.zMin), std::abs(trtPosEC.zMax));
940 
941  trtNegEC.zMin = -absZMaxEC;
942  trtNegEC.zMax = -absZMinEC;
943  trtPosEC.zMin = absZMinEC;
944  trtPosEC.zMax = absZMaxEC;
945 
946  using CVBBV = Acts::CylinderVolumeBounds::BoundValues;
947 
948  // if pixel is present, shrink SCT volumes in R
949  bool isSCTSmallerInZ = false;
950  if (pixel) {
951  ATH_MSG_VERBOSE("Shrinking SCT in R (and maybe in increase size in Z) to fit around Pixel");
952  auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
953  &pixel->volumeBounds());
954  double sctNegECzMin = std::min(sctNegEC.zMin, -pixelBounds->get(CVBBV::eHalfLengthZ));
955  double sctPosECzMax = std::max(sctPosEC.zMax, pixelBounds->get(CVBBV::eHalfLengthZ));
956 
957  ATH_MSG_VERBOSE("- SCT +-EC.rMin: " << sctNegEC.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
958  ATH_MSG_VERBOSE("- SCT BRL.rMin: " << sctBrl.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
959  ATH_MSG_VERBOSE("- SCT EC.zMin: " << sctNegEC.zMin << " -> " << sctNegECzMin);
960  ATH_MSG_VERBOSE("- SCT EC.zMax: " << sctPosEC.zMax << " -> " << sctPosECzMax);
961 
962  sctNegEC.rMin = pixelBounds->get(CVBBV::eMaxR);
963  sctPosEC.rMin = pixelBounds->get(CVBBV::eMaxR);
964  sctBrl.rMin = pixelBounds->get(CVBBV::eMaxR);
965 
966  isSCTSmallerInZ = sctPosEC.zMax < pixelBounds->get(CVBBV::eHalfLengthZ);
967 
968  sctNegEC.zMin = sctNegECzMin;
969  sctPosEC.zMax = sctPosECzMax;
970 
971 
972  } else {
973  ATH_MSG_VERBOSE("Pixel is not configured, not wrapping");
974  }
975 
976  ATH_MSG_VERBOSE("SCT Volume Configuration:");
977  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
978  << " layers, "
979  << sctNegEC.toString());
980  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
981  << sctBrl.toString());
982  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
983  << " layers, "
984  << sctPosEC.toString());
985 
986  ATH_MSG_VERBOSE("TRT Volume Configuration:");
987  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
988  << " layers, "
989  << trtNegEC.toString());
990  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
991  << trtBrl.toString());
992  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
993  << " layers, "
994  << trtPosEC.toString());
995 
996  // harmonize SCT BRL <-> EC, normally the CVB does this, but we're skipping
997  // that
998  sctBrl.zMax = (sctBrl.zMax + sctPosEC.zMin) / 2.;
999  sctBrl.zMin = -sctBrl.zMax;
1000 
1001  // and now harmonize everything
1002  // inflate TRT Barrel to match SCT
1003  trtBrl.zMin = sctBrl.zMin;
1004  trtBrl.zMax = sctBrl.zMax;
1005 
1006  // extend TRT endcaps outwards z so they match SCT
1007  trtNegEC.zMin = sctNegEC.zMin;
1008  trtPosEC.zMax = sctPosEC.zMax;
1009 
1010  // extend endcap in z so it touches barrel
1011  trtNegEC.zMax = trtBrl.zMin;
1012  sctNegEC.zMax = trtBrl.zMin;
1013  trtPosEC.zMin = trtBrl.zMax;
1014  sctPosEC.zMin = trtBrl.zMax;
1015 
1016  // extend SCT in R so they touch TRT barel
1017  sctBrl.rMax = trtBrl.rMin;
1018  sctNegEC.rMax = trtNegEC.rMin;
1019  sctPosEC.rMax = trtPosEC.rMin;
1020 
1021  // extend TRT endcaps in r to that of Barrel
1022  trtNegEC.rMax = trtBrl.rMax;
1023  trtPosEC.rMax = trtBrl.rMax;
1024 
1025  ATH_MSG_VERBOSE("Dimensions after synchronization between SCT and TRT");
1026  ATH_MSG_VERBOSE("SCT Volume Configuration:");
1027  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
1028  << " layers, "
1029  << sctNegEC.toString());
1030  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
1031  << sctBrl.toString());
1032  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
1033  << " layers, "
1034  << sctPosEC.toString());
1035 
1036  ATH_MSG_VERBOSE("TRT Volume Configuration:");
1037  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
1038  << " layers, "
1039  << trtNegEC.toString());
1040  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
1041  << trtBrl.toString());
1042  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
1043  << " layers, "
1044  << trtPosEC.toString());
1045 
1046  auto makeTVol = [&](const auto &vConf, const auto &name) {
1047  return cvh.createTrackingVolume(gctx, vConf.layers, {},
1048  nullptr, // no material
1049  vConf.rMin, vConf.rMax, vConf.zMin,
1050  vConf.zMax, name);
1051  };
1052 
1053  // now turn them into actual TrackingVolumes
1054  auto tvSctNegEC = makeTVol(sctNegEC, "SCT::NegativeEndcap");
1055  auto tvSctBrl = makeTVol(sctBrl, "SCT::Barrel");
1056  auto tvSctPosEC = makeTVol(sctPosEC, "SCT::PositiveEndcap");
1057 
1058  auto tvTrtNegEC = makeTVol(trtNegEC, "TRT::NegativeEndcap");
1059  auto tvTrtBrl = makeTVol(trtBrl, "TRT::Barrel");
1060  auto tvTrtPosEC = makeTVol(trtPosEC, "TRT::PositiveEndcap");
1061 
1062  // combine the endcaps and the barrels, respetively
1063  auto negEC =
1064  cvh.createContainerTrackingVolume(gctx, {tvSctNegEC, tvTrtNegEC});
1065  auto posEC =
1066  cvh.createContainerTrackingVolume(gctx, {tvSctPosEC, tvTrtPosEC});
1067  auto barrel = cvh.createContainerTrackingVolume(gctx, {tvSctBrl, tvTrtBrl});
1068 
1069  // and now combine all of those into one container for the assembly
1070 
1071  auto container =
1072  cvh.createContainerTrackingVolume(gctx, {negEC, barrel, posEC});
1073 
1074  // if pixel is present, add positive and negative gap volumes so we can wrap
1075  // it all
1076  if (pixel) {
1077  auto containerBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
1078  &container->volumeBounds());
1079  auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
1080  &pixel->volumeBounds());
1081  std::vector<std::shared_ptr<Acts::TrackingVolume>> noVolumes;
1082 
1083  if(!isSCTSmallerInZ) {
1084  // pixel is smaller in z, need gap volumes
1085  auto posGap = cvh.createGapTrackingVolume(
1086  gctx, noVolumes,
1087  nullptr, // no material,
1088  pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
1089  pixelBounds->get(CVBBV::eHalfLengthZ),
1090  containerBounds->get(CVBBV::eHalfLengthZ),
1091  0, // material layers,
1092  true, // cylinder
1093  "Pixel::PositiveGap");
1094  auto negGap = cvh.createGapTrackingVolume(
1095  gctx, noVolumes,
1096  nullptr, // no material,
1097  pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
1098  -containerBounds->get(CVBBV::eHalfLengthZ),
1099  -pixelBounds->get(CVBBV::eHalfLengthZ),
1100  0, // material layers,
1101  true, // cylinder
1102  "Pixel::NegativeGap");
1103 
1104  auto pixelContainer =
1105  cvh.createContainerTrackingVolume(gctx, {negGap, pixel, posGap});
1106  // and now create one container that contains Pixel+SCT+TRT
1107  container =
1108  cvh.createContainerTrackingVolume(gctx, {pixelContainer, container});
1109  }
1110  else {
1111  // wrap the pixel directly
1112  container =
1113  cvh.createContainerTrackingVolume(gctx, {pixel, container});
1114  }
1115 
1116  }
1117 
1118  return container;
1119 }

◆ makeStrawLayerBuilder()

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

Definition at line 757 of file ActsTrackingGeometrySvc.cxx.

758  {
759 
760  std::string managerName = manager->getName();
761  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
762  Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
763  const Acts::Surface *
764  /*bS*/) -> bool { return false; };
765 
766  Acts::SurfaceArrayCreator::Config sacCfg;
767  sacCfg.surfaceMatcher = matcher;
768  sacCfg.doPhiBinningOptimization = false;
769 
770  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
771  sacCfg,
772  makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
773  Acts::LayerCreator::Config lcCfg;
774  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
775  auto layerCreator = std::make_shared<Acts::LayerCreator>(
776  lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
777 
778  ActsStrawLayerBuilder::Config cfg;
779  cfg.mng = static_cast<const InDetDD::TRT_DetectorManager *>(manager);
780  cfg.elementStore = m_elementStore;
781  cfg.layerCreator = layerCreator;
782  cfg.idHelper = m_TRT_idHelper;
783  return std::make_shared<const ActsStrawLayerBuilder>(
784  cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
785 }

◆ populateAlignmentStore()

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

Definition at line 1121 of file ActsTrackingGeometrySvc.cxx.

1121  {
1122  ATH_MSG_DEBUG("Populate the alignment store with all detector elements");
1123  unsigned int nElements = 0;
1124  m_trackingGeometry->visitSurfaces([&store, &nElements](const Acts::Surface *srf) {
1125  const auto *detElem = dynamic_cast<const IDetectorElement *>(srf->associatedDetectorElement());
1126  if (!detElem) {
1127  return;
1128  }
1129  nElements += detElem->storeAlignedTransforms(store);
1130  });
1131  ATH_MSG_DEBUG("Populated with " << nElements << " elements");
1132  return nElements;
1133 }

◆ runConsistencyChecks()

bool ActsTrackingGeometrySvc::runConsistencyChecks ( ) const
private

Definition at line 523 of file ActsTrackingGeometrySvc.cxx.

523  {
524  bool result = true;
525 
526  std::vector<Acts::Vector2> localPoints;
527  localPoints.reserve(m_consistencyCheckPoints);
528  std::mt19937 gen;
529  std::uniform_real_distribution<> dist(0.0, 1.0);
530 
531  std::optional<std::ofstream> os;
532  if(!m_consistencyCheckOutput.empty()){
533  os = std::ofstream{m_consistencyCheckOutput};
534  if(!os->good()) {
535  throw std::runtime_error{"Failed to open consistency check output file"};
536  }
537  }
538 
539  if(os) {
540  (*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;
541  }
542  for(size_t i=0;i<m_consistencyCheckPoints;i++) {
543  localPoints.emplace_back(dist(gen), dist(gen));
544  }
545 
546  Acts::GeometryContext gctx = getNominalContext().context();
547 
548  size_t nTotalSensors = 0;
549  std::array<size_t,3> nInconsistent{0,0,0};
550  size_t nMismatchedCenters = 0;
551  size_t nMismatchedNormals = 0;
552 
553  // Comparison of Eigen vectors, similar to a.isApprox(b), but use absolute comparison to also work with zero vectors.
554  // All values will be mm or radians, so 1e-5 is a reasonable precision.
555  auto isApprox = [](auto& a, auto& b) -> bool {
556  return ((a - b).array().abs() < 1e-5).all();
557  };
558 
559  m_trackingGeometry->visitSurfaces([&](const Acts::Surface *surface) {
560  nTotalSensors++;
561 
562  const auto* actsDetElem = dynamic_cast<const ActsDetectorElement*>(surface->associatedDetectorElement());
563  if(actsDetElem == nullptr) {
564  ATH_MSG_ERROR("Invalid detector element found");
565  result = false;
566  return;
567  }
568  const auto* siDetElem = dynamic_cast<const InDetDD::SiDetectorElement*>(actsDetElem->upstreamDetectorElement());
569  if(siDetElem == nullptr) {
570  return;
571  }
572 
573  const auto* regSurface = dynamic_cast<const Acts::RegularSurface*>(surface);
574  const auto& trkSurface = siDetElem->surface();
575  if(regSurface == nullptr) {
576  ATH_MSG_ERROR("Invalid surface found");
577  result = false;
578  return;
579  }
580 
581  Acts::Vector3 center{regSurface->center(gctx)};
582  Amg::Vector3D trkCenter{trkSurface.center()};
583  if (/* auto *b = */ dynamic_cast<const Acts::AnnulusBounds *>(&surface->bounds()))
584  {
585  // // Acts::AnnulusBounds defines center() as center of whole disc, so get it from the bounds
586  // Acts::Vector2 locCenter{0.5 * (b->rMin() + b->rMax()), 0.5 * (b->phiMin() + b->phiMax())};
587  // center = surface->localToGlobal(gctx, locCenter, Acts::Vector3::Zero());
588  center.head<2>() = trkCenter.head<2>(); // that doesn't (quite) work for xy, so just pass that check
589  }
590 
591  if(!isApprox(trkCenter, center)) {
592  std::string trkName;
593  if (auto idHelper = siDetElem->getIdHelper())
594  {
595  trkName = idHelper->show_to_string(siDetElem->identify());
596  }
597  ATH_MSG_WARNING("Acts surface "
598  << surface->geometryId()
599  << " center (" << center[0] << ',' << center[1] << ',' << center[2]
600  << ") does not match Trk surface " << trkName
601  << " center (" << trkCenter[0] << ',' << trkCenter[1] << ',' << trkCenter[2] << ')');
602  nMismatchedCenters++;
603  result = false;
604  }
605 
606  const auto* lineSurface = dynamic_cast<const Acts::LineSurface*>(surface);
607  if(lineSurface == nullptr) {
608  Acts::Vector3 norm{regSurface->normal(gctx, regSurface->center(gctx))};
609  Amg::Vector3D trkNorm{trkSurface.normal()};
610  if(!isApprox(trkNorm, norm)) {
611  std::string trkName;
612  if (auto idHelper = siDetElem->getIdHelper())
613  {
614  trkName = idHelper->show_to_string(siDetElem->identify());
615  }
616  ATH_MSG_WARNING("Acts surface "
617  << surface->geometryId()
618  << " normal (" << norm[0] << ',' << norm[1] << ',' << norm[2]
619  << ") does not match Trk surface " << trkName
620  << " normal (" << trkNorm[0] << ',' << trkNorm[1] << ',' << trkNorm[2] << ')');
621  nMismatchedNormals++;
622  result = false;
623  }
624  }
625 
626  auto doPoints = [&](unsigned int type, const Acts::Vector2& loc) -> std::array<bool,3> {
627  Acts::Vector3 glb = surface->localToGlobal(gctx, loc, Acts::Vector3::Zero());
628 
629  Amg::Vector2D locTrk = Amg::Vector2D::Zero();
630  Amg::Vector3D glbTrk = Amg::Vector3D::Zero();
631  Acts::Vector2 locg2l = Acts::Vector2::Zero();
632  bool locg2lOk = false;
633  auto locTrkRes = trkSurface.globalToLocal(glb);
634  if (locTrkRes) {
635  locTrk = locTrkRes.value();
636  glbTrk = trkSurface.localToGlobal(locTrk);
637 
638  auto locg2lRes = surface->globalToLocal(gctx, glbTrk, Acts::Vector3::Zero());
639  if (locg2lRes.ok()) {
640  locg2lOk = true;
641  locg2l = locg2lRes.value();
642  }
643  }
644 
645  auto gId = surface->geometryId();
646  if(os) {
647  (*os) << gId.value()
648  << "," << gId.volume()
649  << "," << gId.layer()
650  << "," << gId.sensitive()
651  << "," << type
652  << "," << loc[0]
653  << "," << loc[1]
654  << "," << surface->insideBounds(loc)
655  << "," << locTrk[0]
656  << "," << locTrk[1]
657  << "," << trkSurface.insideBounds(locTrk)
658  << "," << glb[0]
659  << "," << glb[1]
660  << "," << glb[2]
661  << "," << locg2l[0]
662  << "," << locg2l[1]
663  << "," << glbTrk[0]
664  << "," << glbTrk[1]
665  << "," << glbTrk[2]
666  << std::endl;
667  }
668 
669  return {surface->insideBounds(loc) == trkSurface.insideBounds(locTrk),
670  locg2lOk ? isApprox(loc, locg2l) : true,
671  locTrkRes ? isApprox(glb, glbTrk) : true};
672  };
673 
674 
675  constexpr double envelope = 10.0 * Acts::UnitConstants::mm;
676 
677  std::array<bool,3> allOk{true,true,true};
678  if(const auto* bounds = dynamic_cast<const Acts::PlanarBounds*>(&surface->bounds()); bounds) {
679  ATH_MSG_VERBOSE("Planar bounds");
680 
681  const Acts::RectangleBounds& boundingBox = bounds->boundingBox();
682  Acts::Vector2 min = boundingBox.min().array() - envelope;
683  Acts::Vector2 max = boundingBox.max().array() + envelope;
684  Acts::Vector2 diag = max - min;
685 
686  for(const auto& testPoint : localPoints) {
687  Acts::Vector2 loc = min.array() + (testPoint.array() * diag.array());
688  auto pointOk = doPoints(0, loc);
689  for (size_t i=0; i<pointOk.size(); ++i) {
690  if (!pointOk[i]) {
691  result = false;
692  allOk[i] = false;
693  }
694  }
695  }
696 
697  }
698  else if(const auto* bounds = dynamic_cast<const Acts::AnnulusBounds*>(&surface->bounds()); bounds) {
699  ATH_MSG_VERBOSE("Annulus bounds");
700 
701  // custom bounding box algo
702  std::vector<Acts::Vector2> vertices = bounds->vertices(5); // 5 segments on the radial edges
703  Acts::Vector2 min{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
704  Acts::Vector2 max{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest()};
705  for (const auto& vtx : vertices) {
706  min = min.array().min(vtx.array());
707  max = max.array().max(vtx.array());
708  }
709  min.array() -= envelope;
710  max.array() += envelope;
711  Acts::Vector2 diag = max - min;
712 
713  for(const auto& testPoint : localPoints) {
714  Acts::Vector2 locXY = min.array() + (testPoint.array() * diag.array());
715  Acts::Vector2 locPC = dynamic_cast<const Acts::DiscSurface&>(*surface).localCartesianToPolar(locXY);
716 
717  auto pointOk = doPoints(1, locPC);
718  for (size_t i=0; i<pointOk.size(); ++i) {
719  if (!pointOk[i]) {
720  result = false;
721  allOk[i] = false;
722  }
723  }
724  }
725 
726  }
727  else {
728  result = false;
729  }
730 
731  for (size_t i=0; i<allOk.size(); ++i) {
732  if (!allOk[i]) {
733  ++nInconsistent[i];
734  }
735  }
736 
737  });
738 
739  ATH_MSG_INFO("Total number of sensors : " << nTotalSensors);
740  ATH_MSG_INFO("Number of sensors with mismatched centers : " << nMismatchedCenters);
741  ATH_MSG_INFO("Number of sensors with mismatched normals : " << nMismatchedNormals);
742  ATH_MSG_INFO("Number of sensors with inconsistent inside: " << nInconsistent[0]);
743  ATH_MSG_INFO("Number of sensors with inconsistent g2l : " << nInconsistent[1]);
744  ATH_MSG_INFO("Number of sensors with inconsistent l2g : " << nInconsistent[2]);
745 
746  return result;
747 }

◆ trackingGeometry()

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

Definition at line 750 of file ActsTrackingGeometrySvc.cxx.

750  {
751 
752  ATH_MSG_VERBOSE("Retrieving tracking geometry");
753  return m_trackingGeometry;
754 }

Member Data Documentation

◆ m_barrelMaterialBins

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

Definition at line 112 of file ActsTrackingGeometrySvc.h.

◆ m_blueprintGraphviz

Gaudi::Property<std::string> ActsTrackingGeometrySvc::m_blueprintGraphviz
private
Initial value:
{this, "BlueprintGraphviz",
"", "Write the blueprint graph to a file. No file will be written if empty"}

Definition at line 153 of file ActsTrackingGeometrySvc.h.

◆ m_blueprintNodeBuilders

ToolHandleArray<ActsTrk::IBlueprintNodeBuilder> ActsTrackingGeometrySvc::m_blueprintNodeBuilders {this, "BlueprintNodeBuilders", {}}
private

Definition at line 145 of file ActsTrackingGeometrySvc.h.

◆ m_buildBeamPipe

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

Definition at line 110 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 114 of file ActsTrackingGeometrySvc.h.

◆ m_caloVolumeBuilder

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

Definition at line 141 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 135 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 138 of file ActsTrackingGeometrySvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> ActsTrackingGeometrySvc::m_detStore
private

Definition at line 89 of file ActsTrackingGeometrySvc.h.

◆ m_doEndcapLayerMerging

Gaudi::Property<bool> ActsTrackingGeometrySvc::m_doEndcapLayerMerging {this, "DoEndcapLayerMerging", true, "Merge overlapping endcap layers in z"}
private

Definition at line 155 of file ActsTrackingGeometrySvc.h.

◆ m_elementStore

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

Definition at line 98 of file ActsTrackingGeometrySvc.h.

◆ m_endcapMaterialBins

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

Definition at line 113 of file ActsTrackingGeometrySvc.h.

◆ m_HGTD_idHelper

const HGTD_ID* ActsTrackingGeometrySvc::m_HGTD_idHelper {nullptr}
private

Definition at line 102 of file ActsTrackingGeometrySvc.h.

◆ m_materialMapCalibFolder

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

Definition at line 109 of file ActsTrackingGeometrySvc.h.

◆ m_materialMapInputFileBase

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

Definition at line 108 of file ActsTrackingGeometrySvc.h.

◆ m_msVolumeBuilder

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

Definition at line 143 of file ActsTrackingGeometrySvc.h.

◆ m_nominalContext

ActsGeometryContext ActsTrackingGeometrySvc::m_nominalContext {}
private

Definition at line 104 of file ActsTrackingGeometrySvc.h.

◆ m_objDebugOutput

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

Definition at line 107 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkInnerPixelBarrelLayerHalflengthZ

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

Definition at line 121 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 120 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkInnerPixelBarrelLayerThickness

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

Definition at line 122 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerHalflengthZ

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

Definition at line 125 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerRadii

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

Definition at line 124 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkOuterPixelBarrelLayerThickness

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

Definition at line 126 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerHalflengthZ

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

Definition at line 129 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerRadii

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

Definition at line 128 of file ActsTrackingGeometrySvc.h.

◆ m_passiveITkStripBarrelLayerThickness

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

Definition at line 130 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 132 of file ActsTrackingGeometrySvc.h.

◆ m_subDetNoAlign

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

Definition at line 150 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 149 of file ActsTrackingGeometrySvc.h.

◆ m_trackingGeometry

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

Definition at line 99 of file ActsTrackingGeometrySvc.h.

◆ m_TRT_idHelper

const TRT_ID* ActsTrackingGeometrySvc::m_TRT_idHelper {nullptr}
private

Definition at line 101 of file ActsTrackingGeometrySvc.h.

◆ m_useBlueprint

Gaudi::Property<bool> ActsTrackingGeometrySvc::m_useBlueprint {this, "UseBlueprint", false, "Use the new Blueprint API for geometry construction"}
private

Definition at line 152 of file ActsTrackingGeometrySvc.h.

◆ m_useMaterialMap

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

Definition at line 106 of file ActsTrackingGeometrySvc.h.

◆ p_beamPipeMgr

const BeamPipeDetectorManager* ActsTrackingGeometrySvc::p_beamPipeMgr {nullptr}
private

Definition at line 95 of file ActsTrackingGeometrySvc.h.

◆ p_HGTDManager

const HGTD_DetectorManager* ActsTrackingGeometrySvc::p_HGTDManager {nullptr}
private

Definition at line 96 of file ActsTrackingGeometrySvc.h.

◆ p_ITkPixelManager

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

Definition at line 93 of file ActsTrackingGeometrySvc.h.

◆ p_ITkStripManager

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

Definition at line 94 of file ActsTrackingGeometrySvc.h.

◆ p_pixelManager

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

Definition at line 90 of file ActsTrackingGeometrySvc.h.

◆ p_SCTManager

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

Definition at line 91 of file ActsTrackingGeometrySvc.h.

◆ p_TRTManager

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

Definition at line 92 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:1137
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:132
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
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:129
ActsTrackingGeometrySvc::m_consistencyCheckOutput
StringProperty m_consistencyCheckOutput
Definition: ActsTrackingGeometrySvc.h:135
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:112
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:523
ActsTrk::actsLevelVector
Acts::Logging::Level actsLevelVector(MSG::Level lvl)
Definition: LoggerUtils.cxx:9
sendEI_SPB.root
root
Definition: sendEI_SPB.py:34
ActsStrawLayerBuilder::Config
Definition: ActsStrawLayerBuilder.h:40
ActsTrackingGeometrySvc::m_consistencyCheckPoints
Gaudi::Property< size_t > m_consistencyCheckPoints
Definition: ActsTrackingGeometrySvc.h:138
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ActsTrackingGeometrySvc::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: ActsTrackingGeometrySvc.h:89
ActsTrackingGeometrySvc::p_ITkPixelManager
const InDetDD::SiDetectorManager * p_ITkPixelManager
Definition: ActsTrackingGeometrySvc.h:93
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:95
ActsTrackingGeometrySvc::m_caloVolumeBuilder
ToolHandle< IActsTrackingVolumeBuilder > m_caloVolumeBuilder
Definition: ActsTrackingGeometrySvc.h:141
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:1134
ActsTrackingGeometrySvc::p_TRTManager
const InDetDD::TRT_DetectorManager * p_TRTManager
Definition: ActsTrackingGeometrySvc.h:92
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:96
ActsTrackingGeometrySvc::m_msVolumeBuilder
ToolHandle< IActsTrackingVolumeBuilder > m_msVolumeBuilder
Definition: ActsTrackingGeometrySvc.h:143
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:86
ActsTrackingGeometrySvc::m_blueprintNodeBuilders
ToolHandleArray< ActsTrk::IBlueprintNodeBuilder > m_blueprintNodeBuilders
Definition: ActsTrackingGeometrySvc.h:145
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrackingGeometrySvc::m_elementStore
std::shared_ptr< ActsElementVector > m_elementStore
Definition: ActsTrackingGeometrySvc.h:98
ActsTrackingGeometrySvc::m_materialMapInputFileBase
Gaudi::Property< std::string > m_materialMapInputFileBase
Definition: ActsTrackingGeometrySvc.h:108
createSimpleDistributions.builder
builder
Definition: createSimpleDistributions.py:51
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ActsTrackingGeometrySvc::m_useBlueprint
Gaudi::Property< bool > m_useBlueprint
Definition: ActsTrackingGeometrySvc.h:152
ActsTrackingGeometrySvc::p_pixelManager
const InDetDD::SiDetectorManager * p_pixelManager
Definition: ActsTrackingGeometrySvc.h:90
calibdata.exception
exception
Definition: calibdata.py:495
ActsTrackingGeometrySvc::p_SCTManager
const InDetDD::SiDetectorManager * p_SCTManager
Definition: ActsTrackingGeometrySvc.h:91
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
ActsTrackingGeometrySvc::m_buildBeamPipe
Gaudi::Property< bool > m_buildBeamPipe
Definition: ActsTrackingGeometrySvc.h:110
ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerRadii
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerRadii
Definition: ActsTrackingGeometrySvc.h:128
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerRadii
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerRadii
Definition: ActsTrackingGeometrySvc.h:124
ActsTrackingGeometrySvc::makeLayerBuilderConfig
ActsLayerBuilder::Config makeLayerBuilderConfig(const InDetDD::InDetDetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:818
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsDetectorElement
Definition: ActsDetectorElement.h:44
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:113
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
ActsTrackingGeometrySvc::m_materialMapCalibFolder
Gaudi::Property< std::string > m_materialMapCalibFolder
Definition: ActsTrackingGeometrySvc.h:109
ActsTrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkInnerPixelBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:122
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:76
ActsTrackingGeometrySvc::m_passiveITkStripBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkStripBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:130
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:906
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:94
CVBBV
Acts::CylinderVolumeBounds::BoundValues CVBBV
Definition: ActsCaloTrackingVolumeBuilder.cxx:31
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerHalflengthZ
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerHalflengthZ
Definition: ActsTrackingGeometrySvc.h:125
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:63
a
TList * a
Definition: liststreamerinfos.cxx:10
ActsTrackingGeometrySvc::m_subDetNoAlign
std::set< ActsTrk::DetectorType > m_subDetNoAlign
Definition: ActsTrackingGeometrySvc.h:150
ActsTrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerThickness
Gaudi::Property< std::vector< float > > m_passiveITkOuterPixelBarrelLayerThickness
Definition: ActsTrackingGeometrySvc.h:126
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DEBUG
#define DEBUG
Definition: page_access.h:11
DetectorZone::barrel
@ barrel
InDetDD::SiDetectorManager
Definition: SiDetectorManager.h:60
HGTD_DetectorManager
Definition: HGTD_DetectorManager.h:33
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
ActsTrackingGeometrySvc::makeStrawLayerBuilder
std::shared_ptr< const Acts::ILayerBuilder > makeStrawLayerBuilder(const InDetDD::InDetDetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:757
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
ActsTrackingGeometrySvc::m_useMaterialMap
Gaudi::Property< bool > m_useMaterialMap
Definition: ActsTrackingGeometrySvc.h:106
ActsTrackingGeometrySvc::m_trackingGeometry
std::shared_ptr< const Acts::TrackingGeometry > m_trackingGeometry
Definition: ActsTrackingGeometrySvc.h:99
DataPrepToActsConfig.pixelContainer
pixelContainer
Definition: DataPrepToActsConfig.py:9
ActsTrackingGeometrySvc::makeHGTDLayerBuilder
std::shared_ptr< const Acts::ILayerBuilder > makeHGTDLayerBuilder(const HGTD_DetectorManager *manager)
Definition: ActsTrackingGeometrySvc.cxx:788
ActsTrackingGeometrySvc::m_buildSubdetectors
Gaudi::Property< std::vector< std::string > > m_buildSubdetectors
Definition: ActsTrackingGeometrySvc.h:114
IdentityHelper
Definition: IdentityHelper.h:14
ActsTrackingGeometrySvc::m_nominalContext
ActsGeometryContext m_nominalContext
Definition: ActsTrackingGeometrySvc.h:104
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
ActsTrackingGeometrySvc::m_TRT_idHelper
const TRT_ID * m_TRT_idHelper
Definition: ActsTrackingGeometrySvc.h:101
ActsTrackingGeometrySvc::m_HGTD_idHelper
const HGTD_ID * m_HGTD_idHelper
Definition: ActsTrackingGeometrySvc.h:102
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:120
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:149
ActsTrackingGeometrySvc::m_objDebugOutput
Gaudi::Property< bool > m_objDebugOutput
Definition: ActsTrackingGeometrySvc.h:107
python.iconfTool.gui.pad.logger
logger
Definition: pad.py:14
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:121
Generated on Sun Aug 31 2025 21:26:35 for ATLAS Offline Software by   doxygen 1.8.18