ActsTrk::TrackingGeometrySvc Class Reference

#include <TrackingGeometrySvc.h>

Inheritance diagram for ActsTrk::TrackingGeometrySvc:

Public Member Functions
	~TrackingGeometrySvc () override
StatusCode	initialize () override
StatusCode	finalize () override
	TrackingGeometrySvc (const std::string &name, ISvcLocator *pSvcLocator)
std::shared_ptr< const Acts::TrackingGeometry >	trackingGeometry () const override
	Returns a pointer to the internal ACTS tracking geometry.
unsigned int	populateAlignmentStore (ActsTrk::DetectorAlignStore &store) const override
	Loops through the volumes of the tracking geometry and caches the aligned transforms in the store.
const ActsTrk::GeometryContext &	getNominalContext () const override
	Returns an empty nominal context without any alignment caches.
const Acts::TrackingVolume *	getEnvelope (const ActsTrk::SystemEnvelope envType) const override
	Returns the envelope volume from the tracking geometry that's containing all volumes of the subsystem.
virtual const ActsTrk::DetectorElementToActsGeometryIdMap *	surfaceIdMap () const override
	Returns the pointer to the identifier mapping between Acts::surface ID & IdentifierHash of the ITk surfaces.
const traccc::host_detector *	detrayGeometry () const override
	Returns the Detray geometry converted from the Acts::TrackingGeometry, or nullptr if none was built.

Private Member Functions
std::unique_ptr< ActsTrk::DetectorElementToActsGeometryIdMap >	createDetectorElementToGeoIdMap () const
	Creates and popules the DetectorElement -> Acts::Surface geo identifier map from the geometry service.
StatusCode	buildDetrayGeometry ()
	Converts the built Acts::TrackingGeometry into a Detray geometry and stores it in m_detrayGeometry.
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}
ActsTrk::GeometryContext	m_nominalContext {}
Gaudi::Property< bool >	m_useMaterialMap {this, "UseMaterialMap", false, ""}
Gaudi::Property< bool >	m_objDebugOutput {this, "ObjDebugOutput", false, ""}
Gaudi::Property< bool >	m_keepGoingOnMaterialMergeFailure {this, "KeepGoingOnMaterialMergeFailure", 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< bool >	m_printGeo {this, "printGeometry", false}
	Print the assembled tracking geometry after building.
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
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", ""}
ToolHandleArray< ActsTrk::IBlueprintNodeBuilder >	m_blueprintNodeBuilders {this, "BlueprintNodeBuilders", {}}
ToolHandleArray< ActsTrk::IRefineTrackingGeoTool >	m_refineVisitors {this, "RefinementTools", {}}
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.
std::set< ActsTrk::DetectorType >	m_subDetNoAlign {}
Gaudi::Property< bool >	m_useBlueprint {this, "UseBlueprint", false, "Use the new Blueprint API for geometry construction"}
Gaudi::Property< bool >	m_buildDetrayGeometry
Gaudi::Property< bool >	m_checkDetrayGeometry
Gaudi::Property< bool >	m_buildDetraySurfaceGrids
Gaudi::Property< bool >	m_buildDetrayMaterial
ToolHandle< AthDevice::IMemoryResourceTool >	m_hostMR
	Tool providing the memory resource that the Detray geometry is allocated from.
Gaudi::Property< std::string >	m_blueprintGraphviz
Gaudi::Property< bool >	m_doEndcapLayerMerging {this, "DoEndcapLayerMerging", true, "Merge overlapping endcap layers in z"}
Gaudi::Property< double >	m_numberOfBinsFactor {this, "NumberOfBinsFactor", 5.0}
	controls how many bins are created for the sensitive surface grid.
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelInnerBarrelNeighborWindow
	Most bins the surface array lookup serves on each side of the crossing, as {phi, z} for the barrel and {r, phi} for the endcap.
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelInnerEndcapNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelOuterBarrelNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelOuterEndcapNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkStripBarrelNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkStripEndcapNeighborWindow
Gaudi::Property< unsigned int >	m_surfaceArrayOverfill
	Extra cells per direction and axis that each surface fills around its footprint.
Gaudi::Property< double >	m_numberOfHgtdBinsFactor {this, "NumberOfHgtdBinsFactor", 5.0}
	Special treatment for hgtd layers as well.
std::unique_ptr< const ActsTrk::DetectorElementToActsGeometryIdMap >	m_detIdMap {}
std::unique_ptr< traccc::host_detector >	m_detrayGeometry

Detailed Description

Definition at line 59 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

Constructor & Destructor Documentation

~TrackingGeometrySvc()

ActsTrk::TrackingGeometrySvc::~TrackingGeometrySvc ( )

overridedefault

TrackingGeometrySvc()

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

Definition at line 120 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

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

Member Function Documentation

buildDetrayGeometry()

StatusCode ActsTrk::TrackingGeometrySvc::buildDetrayGeometry ( )

private

Converts the built Acts::TrackingGeometry into a Detray geometry and stores it in m_detrayGeometry.

Definition at line 1364 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                    {
  using DetrayDetector = traccc::itk_detector;
  using DetrayMetadata = detray::detector_metadata_t<DetrayDetector>;
  using namespace ActsTrk::detail::GeoVolIds;
  // The Detray detector allocates through this memory resource and keeps
  // referring to it for the deallocations, so the tool has to be held for as
  // long as m_detrayGeometry lives.
  if (m_hostMR.empty()) {
    ATH_MSG_ERROR("BuildDetrayGeometry was requested, but no host memory "
                  "resource tool was configured (HostMR)");
    return StatusCode::FAILURE;
  }
  ATH_CHECK(m_hostMR.retrieve());
 
  // Detray puts the beam pipe volume at detector index 0 and requires it to
  // contain the origin, so resolve it by position instead of by GeometryIdentifier.
  // An id-based lookup would not work anyway: BeamPipeBlueprintNodeBuilder assigns
  // s_beamPipeVolumeId to *every* volume of the beam pipe subtree (the static
  // cylinder plus whatever gap volumes the container spawned) and hands out layer
  // ids incrementally starting at 1, so findVolume() on volume=s_beamPipeVolumeId
  // -- which implies layer == 0 -- never matches.
  auto beamPipeResult = m_trackingGeometry->resolveLowestTrackingVolume(
      getNominalContext().context(), Acts::Vector3::Zero());
  if (!beamPipeResult.ok()) {
    ATH_MSG_ERROR("BuildDetrayGeometry was requested, but the tracking volume "
                  "containing the origin could not be resolved: "
                  << beamPipeResult.error().message());
    return StatusCode::FAILURE;
  }
 
  const Acts::TrackingVolume* beamPipeVolume = *beamPipeResult;
  if (beamPipeVolume == nullptr) {
    ATH_MSG_ERROR("BuildDetrayGeometry was requested, but no tracking volume "
                  "contains the origin. Detray requires a beam pipe volume "
                  "covering (0, 0, 0).");
    return StatusCode::FAILURE;
  }
  if (beamPipeVolume->geometryId().volume() != s_beamPipeVolumeId) {
    ATH_MSG_WARNING("The tracking volume containing the origin, '"
                    << beamPipeVolume->volumeName() << "' ("
                    << beamPipeVolume->geometryId()
                    << "), is not part of the beam pipe subtree (expected "
                       "GeometryIdentifier volume=" << s_beamPipeVolumeId
                    << "). Using it as the Detray beam pipe volume regardless.");
  }
  ATH_MSG_INFO("Using '" << beamPipeVolume->volumeName() << "' ("
               << beamPipeVolume->geometryId() << ") as the Detray beam pipe volume");
 
  ActsPlugins::DetrayPayloadConverter::Config payloadConfig{};
  payloadConfig.beampipeVolume = beamPipeVolume;
 
  auto payloadConverter = std::make_shared<const ActsPlugins::DetrayPayloadConverter>(
      payloadConfig,
      makeActsAthenaLogger(this, "DetrayPayloadCnv", std::string("ActsTGSvc")));
 
  ActsPlugins::DetrayGeometryConverter::Config converterConfig{};
  converterConfig.payloadConverter = std::move(payloadConverter);
  converterConfig.convertSurfaceGrids = m_buildDetraySurfaceGrids;
  converterConfig.convertMaterial = m_buildDetrayMaterial;
 
  ActsPlugins::DetrayGeometryConverter converter(
      std::move(converterConfig),
      makeActsAthenaLogger(this, "DetrayGeomCnv", std::string("ActsTGSvc")));
 
  ActsPlugins::DetrayGeometryConverter::DetrayGeometry<DetrayMetadata> detrayGeometry{};
  try {
    detrayGeometry = converter.convert<DetrayMetadata>(
        m_hostMR->mr(), getNominalContext().context(), m_trackingGeometry, name());
  } catch (const std::exception& e) {
    ATH_MSG_ERROR("Failed to convert the Acts::TrackingGeometry into a Detray geometry: " << e.what());
    return StatusCode::FAILURE;
  }
 
  if (!detrayGeometry.detector) {
    ATH_MSG_ERROR("Detray geometry conversion did not produce a detector");
    return StatusCode::FAILURE;
  }
 
  if (m_checkDetrayGeometry) {
    ATH_MSG_INFO("Checking the consistency of the converted Detray geometry");
    try {
      detray::detail::check_consistency(*detrayGeometry.detector, true,
                                        detrayGeometry.names);
    } catch (const std::exception& e) {
      ATH_MSG_ERROR("The converted Detray geometry is not consistent: " << e.what());
      return StatusCode::FAILURE;
    }
    const auto reportDetrayPortalLinks = [this](
        const auto& detector, const detray::name_map& names) {
      const std::size_t nVolumes = detector.volumes().size();
 
      // Directed portal graph: outgoing[a] holds every volume a portal of
      // volume a links into. A healthy interface between a and b shows up as
      // a -> b and b -> a.
      std::vector<std::set<detray::dindex>> outgoing(nVolumes);
      std::size_t nPortals{0};
      std::size_t nEndOfWorld{0};
 
      for (const auto& volDesc : detector.volumes()) {
        const auto volume = detray::tracking_volume{detector, volDesc};
        const detray::dindex volIdx = volume.index();
 
        for (const auto& sfDesc : volume.portals()) {
          const auto surface = detray::geometry::surface{detector, sfDesc};
          ++nPortals;
 
          for (const auto link : surface.volume_links()) {
            if (detray::detail::is_invalid_value(link)) {
              ++nEndOfWorld;
              continue;
            }
            if (link == volIdx || link >= nVolumes) {
              continue;
            }
            outgoing[volIdx].insert(link);
          }
        }
      }
 
      std::size_t nReciprocal{0};
      std::vector<std::pair<detray::dindex, detray::dindex>> oneWay;
      for (detray::dindex a = 0; a < nVolumes; ++a) {
        for (const detray::dindex b : outgoing[a]) {
          if (outgoing[b].contains(a)) {
            ++nReciprocal;
          } else {
            oneWay.emplace_back(a, b);
          }
        }
      }
 
      auto volName = [&names](detray::dindex idx) -> std::string {
        return names.contains(idx) ? names.at(idx)
                                   : std::format("volume {:}", idx);
      };
 
      ATH_MSG_INFO("Detray portal links: " << nPortals
                   << " portal surfaces, " << nEndOfWorld
                   << " end-of-world links, " << (nReciprocal / 2)
                   << " reciprocal volume interfaces, " << oneWay.size()
                   << " one-directional");
 
      if (!oneWay.empty()) {
        ATH_MSG_WARNING(oneWay.size()
                        << " portal links are one-directional: the neighbour "
                           "volume has no portal linking back. Detray's "
                           "check_consistency() does not catch this.");
        const std::size_t nShow =
            std::min<std::size_t>(oneWay.size(), 20);
        for (std::size_t i = 0; i < nShow; ++i) {
          ATH_MSG_WARNING("  one-way: '" << volName(oneWay[i].first) << "' ("
                          << oneWay[i].first << ") -> '"
                          << volName(oneWay[i].second) << "' ("
                          << oneWay[i].second << ") with no return link");
        }
        if (oneWay.size() > nShow) {
          ATH_MSG_WARNING("  ... and " << (oneWay.size() - nShow) << " more");
        }
      }
    };
    reportDetrayPortalLinks(*detrayGeometry.detector, detrayGeometry.names);
  }
 
  auto hostDetector = std::make_unique<traccc::host_detector>();
  hostDetector->set<DetrayDetector>(std::move(*detrayGeometry.detector));
  m_detrayGeometry = std::move(hostDetector);
 
  ATH_MSG_INFO("Successfully built the Detray geometry from the Acts::TrackingGeometry");
  return StatusCode::SUCCESS;
}

createDetectorElementToGeoIdMap()

std::unique_ptr< ActsTrk::DetectorElementToActsGeometryIdMap > ActsTrk::TrackingGeometrySvc::createDetectorElementToGeoIdMap ( ) const

private

Creates and popules the DetectorElement -> Acts::Surface geo identifier map from the geometry service.

Muon system

Definition at line 1536 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                               {
    // create map from
    auto detector_element_to_geoid = std::make_unique<DetectorElementToActsGeometryIdMap>();
 
    struct Counter{ 
        unsigned n_sensitive_elements{0};
        unsigned n_detector_elements{0};
        unsigned n_wrong_type{0};
    };
    Counter counter {};
    trackingGeometry()->visitSurfaces([this, &counter, &detector_element_to_geoid](const Acts::Surface *surface) {
        if (!surface || !surface->isSensitive()) {
            ++counter.n_wrong_type;
            return;
        }
        ++counter.n_sensitive_elements;
        const auto* placement = dynamic_cast<const ISurfacePlacement*>(surface->surfacePlacement());
        if (!placement) {           
            return;
        }
 
        auto insert_id = [&detector_element_to_geoid, &surface, &counter](const xAOD::UncalibMeasType type) {
            auto * possibleElement = getActsDetectorElement(surface);
            if (!possibleElement){
              return;
            } 
            auto hash = possibleElement->identifyHash();
            detector_element_to_geoid->insert(std::make_pair(makeDetectorElementKey(type, hash),
                                                             DetectorElementToActsGeometryIdMap::makeValue(surface->geometryId(), surface)));
            ++counter.n_detector_elements;
        };
        switch(placement->detectorType()) {
            using enum DetectorType;
            case Pixel:
                insert_id(xAOD::UncalibMeasType::PixelClusterType);
                break;
            case Sct:
                insert_id(xAOD::UncalibMeasType::StripClusterType);
                break;
            case Hgtd:
                insert_id(xAOD::UncalibMeasType::HGTDClusterType);
                break;
            case Trt: {
                break;
            }
            case Mdt:
            case Rpc:
            case Tgc:
            case Csc:
            case Mm:
            case sTgc:{
                // surface map not needed for the muon detectors
               ++counter.n_detector_elements; 
               break;
            }
            case UnDefined:
                ATH_MSG_ERROR("Undefined element encountered");
                counter.n_detector_elements = 0;
                return;
        }
    }, true /*sensitive surfaces*/);
    ATH_MSG_INFO( "Surfaces without associated detector elements " << (counter.n_sensitive_elements -counter.n_detector_elements)
                << " (with " << counter.n_detector_elements << ")" );
    if (counter.n_sensitive_elements > 0 && 
        counter.n_detector_elements==0) {
        ATH_MSG_ERROR( "No surface with associated detector element" );
        return nullptr;
    }
    if (counter.n_wrong_type>0) {
        ATH_MSG_WARNING( "Surfaces associated to detector elements not of type Trk::TrkDetElementBase :" << counter.n_wrong_type);
    }
    return detector_element_to_geoid;
}

detrayGeometry()

const traccc::host_detector * ActsTrk::TrackingGeometrySvc::detrayGeometry ( ) const

inlineoverride

Returns the Detray geometry converted from the Acts::TrackingGeometry, or nullptr if none was built.

The service stays the owner: the geometry is released in finalize(), while the memory resource it was allocated from is still around. Only populated when the BuildDetrayGeometry property is enabled.

Definition at line 84 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                             {
    return m_detrayGeometry.get();
  }

finalize()

StatusCode ActsTrk::TrackingGeometrySvc::finalize ( )

override

Definition at line 1356 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                         {
  // Release the Detray geometry while the memory resource tool it allocated
  // from is still around, which is not guaranteed any more once the service
  // itself is destroyed.
  m_detrayGeometry.reset();
  return AthService::finalize();
}

getEnvelope()

const Acts::TrackingVolume * ActsTrk::TrackingGeometrySvc::getEnvelope ( const ActsTrk::SystemEnvelope envType ) const

override

Returns the envelope volume from the tracking geometry that's containing all volumes of the subsystem.

Definition at line 1327 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                                                {
      const Acts::TrackingVolume* retVol{nullptr};
      using namespace ActsTrk::detail::GeoVolIds;
      switch (envType) {
          using enum ActsTrk::SystemEnvelope;
          case ITkExit:
              retVol = m_trackingGeometry->findVolume(volumeId(s_ITkEnvelopeId));
              break;
          case HgtdExit:
              retVol = m_trackingGeometry->findVolume(volumeId(s_hgtdEnvelopeId));
              break;
          case HgtdSideA:
              retVol = m_trackingGeometry->findVolume(volumeId(s_hgtdPosVolumeId));
              break;
          case HgtdSideC:
              retVol = m_trackingGeometry->findVolume(volumeId(s_hgtdNegVolumeId));
              break;
          case CaloExit:
              retVol = m_trackingGeometry->findVolume(volumeId(s_caloEnvelopeID));
              break;
          case MsExit:
              break;
      }
      if(!retVol) {
        ATH_MSG_WARNING("There is no system envelope "<<envType);
      }
      return retVol;
}

getNominalContext()

const GeometryContext & ActsTrk::TrackingGeometrySvc::getNominalContext ( ) const

override

Returns an empty nominal context without any alignment caches.

Definition at line 1244 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

{ return m_nominalContext; }

initialize()

StatusCode ActsTrk::TrackingGeometrySvc::initialize ( )

override

Definition at line 130 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                           {
  ATH_MSG_INFO(name() << " is initializing");
  for (unsigned int skipAlign : m_subDetNoAlignProp) {
    try {
        m_subDetNoAlign.insert(static_cast<DetectorType>(skipAlign));
    } catch (...) {
        ATH_MSG_FATAL("Failed to interpret " << m_subDetNoAlignProp << " as ActsDetectorElements");
        return StatusCode::FAILURE;
    }
  }
  ATH_CHECK(m_caloVolumeBuilder.retrieve(EnableTool{!m_caloVolumeBuilder.empty()}));
 
  // FIXME: ActsCaloTrackingVolumeBuilder holds ReadHandle to
  // CaloDetDescrManager. Hopefully this service is never called before that
  // object is available.
  m_autoRetrieveTools = false;
  m_checkToolDeps = false;
 
  ATH_MSG_INFO("ACTS version is: v"
               << Acts::VersionMajor << "." << Acts::VersionMinor << "."
               << Acts::VersionPatch << " [" << Acts::CommitHash.value_or("unknown hash") << "]");
 
  // load which subdetectors to build from property
  std::set<std::string, std::less<>> buildSubdet(m_buildSubdetectors.begin(),
                                    m_buildSubdetectors.end());
  ATH_MSG_INFO("Configured to build " << buildSubdet.size()
                                      << " subdetectors:");
  for (const auto &s : buildSubdet) {
    ATH_MSG_INFO(" - " << s);
  }
 
  for (const Gaudi::Property<std::vector<unsigned int>>* window :
       {&m_itkPixelInnerBarrelNeighborWindow, &m_itkPixelInnerEndcapNeighborWindow,
        &m_itkPixelOuterBarrelNeighborWindow, &m_itkPixelOuterEndcapNeighborWindow,
        &m_itkStripBarrelNeighborWindow, &m_itkStripEndcapNeighborWindow}) {
    if (!toNeighborWindow(window->value()).has_value()) {
      ATH_MSG_FATAL((*window)
                    << " must hold two bin counts of at most "
                    << static_cast<unsigned int>(std::numeric_limits<std::uint8_t>::max()));
      return StatusCode::FAILURE;
    }
  }
  if (m_surfaceArrayOverfill.value() > std::numeric_limits<std::uint8_t>::max()) {
    ATH_MSG_FATAL(m_surfaceArrayOverfill
                  << " exceeds " << static_cast<unsigned int>(std::numeric_limits<std::uint8_t>::max()));
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Loading detector manager(s)");
  if (buildSubdet.contains("Pixel") ) {
    ATH_CHECK(m_detStore->retrieve(p_pixelManager, "Pixel"));
  }
  if (buildSubdet.contains("SCT") ) {
    ATH_CHECK(m_detStore->retrieve(p_SCTManager, "SCT"));
  }
  if (buildSubdet.contains("TRT") ) {
    ATH_CHECK(m_detStore->retrieve(p_TRTManager, "TRT"));
    ATH_CHECK(m_detStore->retrieve(m_TRT_idHelper, "TRT_ID"));
  }
  if (buildSubdet.contains("ITkPixel") ) {
    ATH_CHECK(m_detStore->retrieve(p_ITkPixelManager, "ITkPixel"));
  }
  if (buildSubdet.contains("ITkStrip") ) {
    ATH_CHECK(m_detStore->retrieve(p_ITkStripManager, "ITkStrip"));
  }
  if (buildSubdet.contains("HGTD") ) {
    ATH_CHECK(m_detStore->retrieve(p_HGTDManager, "HGTD"));
    ATH_CHECK(m_detStore->retrieve(m_HGTD_idHelper, "HGTD_ID"));
  }
 
  if(m_buildBeamPipe) {
    ATH_CHECK(m_detStore->retrieve(p_beamPipeMgr, "BeamPipe"));
  }
 
  // Consistency check on the size vectors for passive layers
  if (m_passiveITkInnerPixelBarrelLayerRadii.size() != m_passiveITkInnerPixelBarrelLayerHalflengthZ.size() ||
    m_passiveITkInnerPixelBarrelLayerHalflengthZ.size() != m_passiveITkInnerPixelBarrelLayerThickness.size()) {
        ATH_MSG_FATAL("Consistency check for ITk inner pixel barrel passive layer construction failed. Please check your inputs! ");
        return StatusCode::FAILURE;
  }
 
  if (m_passiveITkOuterPixelBarrelLayerRadii.size() != m_passiveITkOuterPixelBarrelLayerHalflengthZ.size() ||
    m_passiveITkOuterPixelBarrelLayerHalflengthZ.size() != m_passiveITkOuterPixelBarrelLayerThickness.size()) {
        ATH_MSG_FATAL("Consistency check for ITk outer pixel barrel passive layer construction failed. Please check your inputs! ");
        return StatusCode::FAILURE;
  }
 
  if (m_passiveITkStripBarrelLayerRadii.size() != m_passiveITkStripBarrelLayerHalflengthZ.size() ||
    m_passiveITkStripBarrelLayerHalflengthZ.size() != m_passiveITkStripBarrelLayerThickness.size()) {
        ATH_MSG_FATAL("Consistency check for ITk strip barrel passive layer construction failed. Please check your inputs! ");
        return StatusCode::FAILURE;
  }
 
  if (m_useBlueprint) {
 
 
    ATH_MSG_INFO("Using Blueprint API for geometry construction");
    std::set<std::string, std::less<>> buildSubdet(m_buildSubdetectors.begin(),
                                     m_buildSubdetectors.end());
 
    ATH_CHECK(m_blueprintNodeBuilders.retrieve());
    ATH_CHECK(m_refineVisitors.retrieve());
 
    using enum Acts::AxisDirection;
  
    std::vector<ActsTrk::IBlueprintNodeBuilder*> ptrBuilders;
    std::transform(m_blueprintNodeBuilders.begin(), m_blueprintNodeBuilders.end(),
               std::back_inserter(ptrBuilders),
               [](ToolHandle<ActsTrk::IBlueprintNodeBuilder>& b) { return b.get(); });
 
    auto logger = makeActsAthenaLogger(this, name());
    
    Acts::Blueprint::Config cfg;
    cfg.envelope[AxisZ] = {20_mm, 20_mm};
    cfg.envelope[AxisR] = {0_mm, 20_mm};
 
    auto blueprint = std::make_unique<Acts::Blueprint>(cfg);
 
    auto& root = blueprint->addCylinderContainer("Detector", AxisZ);
    //The starting top node 
    std::shared_ptr<Acts::BlueprintNode> currentTop{nullptr};
 
    for (auto& builder : ptrBuilders) {
      currentTop = builder->buildBlueprintNode(getNominalContext().context(), std::move(currentTop));
      
    }
 
    root.addChild(std::move(currentTop));
    
    Acts::BlueprintOptions blueprintOptions;
    blueprintOptions.keepGoingOnMaterialMergeFailure = m_keepGoingOnMaterialMergeFailure;
    std::unique_ptr<Acts::TrackingGeometry> trackingGeometry = blueprint->construct(
      blueprintOptions, getNominalContext().context(), *logger->clone(std::nullopt, Acts::Logging::DEBUG));
 
    for (auto& refineVisitor : m_refineVisitors) {
        trackingGeometry->apply(*refineVisitor);
        ATH_CHECK(refineVisitor->finalize());
    }
    m_refineVisitors.clear();
    
    m_trackingGeometry = std::move(trackingGeometry);
 
    if (m_objDebugOutput) {
      Acts::ObjVisualization3D vis;
      m_trackingGeometry->visualize(vis, getNominalContext().context(),
                                  viewConfigFunc({.visible = true}, {.visible = false}, {.visible = false}));
      vis.write("blueprint_envelopes.obj");
      vis.clear();
 
      m_trackingGeometry->visualize(vis, getNominalContext().context(),
                                  viewConfigFunc({.visible = false}, {.visible = true}, {.visible = false}));
      vis.write("blueprint_portals.obj");
 
      m_trackingGeometry->visualize(vis, getNominalContext().context(),
                                  viewConfigFunc({.visible = false}, {.visible = false}, {.visible = true}));
      vis.write("blueprint_sensitive.obj");
      vis.clear();
 
    }
    if (m_printGeo) {
        Acts::detail::TrackingGeometryPrintVisitor printer{m_nominalContext.context()};
        m_trackingGeometry->apply(printer);
        ATH_MSG_INFO("Built tracking geometry \n"<<printer.stream().str());
    }
    m_detIdMap = createDetectorElementToGeoIdMap();
    if (!m_detIdMap) {
        return StatusCode::FAILURE;
    }
 
    if (m_buildDetrayGeometry) {
      ATH_CHECK(buildDetrayGeometry());
    }
 
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Setting up ACTS geometry helpers");
 
  Acts::LayerArrayCreator::Config lacCfg;
  auto layerArrayCreator = std::make_shared<const Acts::LayerArrayCreator>(
      lacCfg, makeActsAthenaLogger(this, std::string("LayArrCrtr"), std::string("ActsTGSvc")));
 
  Acts::TrackingVolumeArrayCreator::Config tvcCfg;
  auto trackingVolumeArrayCreator =
      std::make_shared<const Acts::TrackingVolumeArrayCreator>(
          tvcCfg, makeActsAthenaLogger(this, std::string("TrkVolArrCrtr"), std::string("ActsTGSvc")));
 
  Acts::CylinderVolumeHelper::Config cvhConfig;
  cvhConfig.layerArrayCreator = layerArrayCreator;
  cvhConfig.trackingVolumeArrayCreator = trackingVolumeArrayCreator;
 
  auto cylinderVolumeHelper =
      std::make_shared<const Acts::CylinderVolumeHelper>(
          cvhConfig, makeActsAthenaLogger(this, std::string("CylVolHlpr"), std::string("ActsTGSvc")));
 
  Acts::TrackingGeometryBuilder::Config tgbConfig;
  tgbConfig.trackingVolumeHelper = cylinderVolumeHelper;
 
  if (m_useMaterialMap) {
    std::shared_ptr<const Acts::IMaterialDecorator> matDeco = nullptr;
 
    std::string matFileFullPath = PathResolverFindCalibFile(m_materialMapCalibFolder.value()+"/"+m_materialMapInputFileBase.value());
    if (matFileFullPath.empty()) {
      ATH_MSG_ERROR( "Material Map Input File " << m_materialMapCalibFolder.value() << "/" << m_materialMapInputFileBase.value() << " not found.");
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("Configured to use material input: " << matFileFullPath);
 
    if (matFileFullPath.find(".json") != std::string::npos) {
      // Set up the converter first
      Acts::MaterialMapJsonConverter::Config jsonGeoConvConfig;
      // Set up the json-based decorator
      matDeco = std::make_shared<const Acts::JsonMaterialDecorator>(
       jsonGeoConvConfig, matFileFullPath, ActsTrk::actsLevelVector(msg().level()));
    }
    tgbConfig.materialDecorator = std::move(matDeco);
  }
 
  std::array<double, 2> sctECEnvelopeZ{20_mm, 20_mm};
 
  try {
    // BeamPipe
    if(m_buildBeamPipe) {
      tgbConfig.trackingVolumeBuilders.push_back([&](const auto &gctx,
                                                     const auto &inner,
                                                     const auto &) {
 
        Acts::CylinderVolumeBuilder::Config bpvConfig =
          makeBeamPipeConfig(cylinderVolumeHelper);
 
        Acts::CylinderVolumeBuilder beamPipeVolumeBuilder {
          bpvConfig, makeActsAthenaLogger(this, std::string("BPVolBldr"), std::string("ActsTGSvc"))};
 
        return beamPipeVolumeBuilder.trackingVolume(gctx, inner);
      });
    }
 
 
 
    // PIXEL
    if (buildSubdet.contains("Pixel")) {
      tgbConfig.trackingVolumeBuilders.push_back([&](const auto &gctx,
                                                     const auto &inner,
                                                     const auto &) {
        auto cfg = makeLayerBuilderConfig(p_pixelManager);
        cfg.mode = ActsLayerBuilder::Mode::Pixel;
        auto lb = std::make_shared<ActsLayerBuilder>(
            cfg, makeActsAthenaLogger(this, std::string("PixelGMSLayBldr"), std::string("ActsTGSvc")));
        Acts::CylinderVolumeBuilder::Config cvbConfig;
        cvbConfig.layerEnvelopeR = {3_mm, 3_mm};
        cvbConfig.layerEnvelopeZ = 1_mm;
        cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
        cvbConfig.volumeName = "Pixel";
        cvbConfig.layerBuilder = lb;
        cvbConfig.buildToRadiusZero = !m_buildBeamPipe;
 
        Acts::CylinderVolumeBuilder cvb(
            cvbConfig, makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
 
        return cvb.trackingVolume(gctx, inner);
      });
    }
 
    // ITK PIXEL
    if (buildSubdet.contains("ITkPixel") ) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto cfg = makeLayerBuilderConfig(p_ITkPixelManager);
            cfg.mode = ActsLayerBuilder::Mode::ITkPixelInner;
            cfg.barrelNeighborWindow = *toNeighborWindow(m_itkPixelInnerBarrelNeighborWindow);
            cfg.endcapNeighborWindow = *toNeighborWindow(m_itkPixelInnerEndcapNeighborWindow);
            cfg.objDebugOutput = m_objDebugOutput;
            cfg.doEndcapLayerMerging = true;
            cfg.passiveBarrelLayerRadii = m_passiveITkInnerPixelBarrelLayerRadii;
            cfg.passiveBarrelLayerHalflengthZ = m_passiveITkInnerPixelBarrelLayerHalflengthZ;
            cfg.passiveBarrelLayerThickness = m_passiveITkInnerPixelBarrelLayerThickness;
            auto lb = std::make_shared<ActsLayerBuilder>(
                cfg, makeActsAthenaLogger(this, std::string("ITkPxInLb"), std::string("ActsTGSvc")));
 
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 1_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "ITkPixelInner";
            cvbConfig.layerBuilder = lb;
            cvbConfig.buildToRadiusZero = !m_buildBeamPipe;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
 
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto cfg = makeLayerBuilderConfig(p_ITkPixelManager);
            cfg.mode = ActsLayerBuilder::Mode::ITkPixelOuter;
            cfg.barrelNeighborWindow = *toNeighborWindow(m_itkPixelOuterBarrelNeighborWindow);
            cfg.endcapNeighborWindow = *toNeighborWindow(m_itkPixelOuterEndcapNeighborWindow);
            cfg.objDebugOutput = m_objDebugOutput;
            cfg.doEndcapLayerMerging = false;
            cfg.passiveBarrelLayerRadii = m_passiveITkOuterPixelBarrelLayerRadii;
            cfg.passiveBarrelLayerHalflengthZ = m_passiveITkOuterPixelBarrelLayerHalflengthZ;
            cfg.passiveBarrelLayerThickness = m_passiveITkOuterPixelBarrelLayerThickness;
            auto lb = std::make_shared<ActsLayerBuilder>(
                cfg, makeActsAthenaLogger(this, std::string("ITkPxOtLb"), std::string("ActsTGSvc")));
 
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 1_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "ITkPixelOuter";
            cvbConfig.layerBuilder = lb;
            cvbConfig.buildToRadiusZero = false;
            cvbConfig.checkRingLayout = true;
            cvbConfig.ringTolerance = 10_mm;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
    }
 
    // ITK STRIP
    if (buildSubdet.contains("ITkStrip")) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto cfg = makeLayerBuilderConfig(p_ITkStripManager);
            cfg.mode = ActsLayerBuilder::Mode::ITkStrip;
            cfg.barrelNeighborWindow = *toNeighborWindow(m_itkStripBarrelNeighborWindow);
            cfg.endcapNeighborWindow = *toNeighborWindow(m_itkStripEndcapNeighborWindow);
            cfg.objDebugOutput = m_objDebugOutput;
            cfg.passiveBarrelLayerRadii = m_passiveITkStripBarrelLayerRadii;
            cfg.passiveBarrelLayerHalflengthZ = m_passiveITkStripBarrelLayerHalflengthZ;
            cfg.passiveBarrelLayerThickness = m_passiveITkStripBarrelLayerThickness;
            auto lb = std::make_shared<ActsLayerBuilder>(
                cfg, makeActsAthenaLogger(this, std::string("ITkStripLB"), std::string("ActsTGSvc")));
 
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 1_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "ITkStrip";
            cvbConfig.layerBuilder = lb;
            cvbConfig.buildToRadiusZero = 
              !buildSubdet.contains("ITkPixel") && !m_buildBeamPipe;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("CylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
    }
 
    bool buildSCT = buildSubdet.contains("SCT") ;
    bool buildTRT = buildSubdet.contains("TRT");
 
    if (buildSCT && buildTRT) {
      // building both we need to take care
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto cfg = makeLayerBuilderConfig(p_SCTManager);
            cfg.mode = ActsLayerBuilder::Mode::SCT;
            cfg.endcapEnvelopeZ = sctECEnvelopeZ;
            auto sct_lb = std::make_shared<ActsLayerBuilder>(
                cfg, makeActsAthenaLogger(this, std::string("SCTGMSLayBldr"), std::string("ActsTGSvc")));
 
            auto trt_lb = makeStrawLayerBuilder(p_TRTManager);
 
            return makeSCTTRTAssembly(gctx, *sct_lb, *trt_lb,
                                      *cylinderVolumeHelper, inner);
          });
 
    } else if (buildSCT) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto lbCfg = makeLayerBuilderConfig(p_SCTManager);
            lbCfg.mode = ActsLayerBuilder::Mode::SCT;
            lbCfg.endcapEnvelopeZ = sctECEnvelopeZ;
            auto lb = std::make_shared<ActsLayerBuilder>(
                lbCfg,
                makeActsAthenaLogger(this, std::string("SCTGMSLayBldr"), std::string("ActsTGSvc")));
 
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 2_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "SCT";
            cvbConfig.layerBuilder = lb;
            cvbConfig.buildToRadiusZero = false;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("SCTCylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
    } else if (buildTRT) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto lb = makeStrawLayerBuilder(p_TRTManager);
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 2_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "TRT";
            cvbConfig.layerBuilder = std::move(lb);
            cvbConfig.buildToRadiusZero = false;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("TRTCylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
    }
 
    //HGTD
    if(buildSubdet.contains("HGTD") ) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            auto lb = makeHGTDLayerBuilder(p_HGTDManager); //using ActsHGTDLayerBuilder
            Acts::CylinderVolumeBuilder::Config cvbConfig;
            cvbConfig.layerEnvelopeR = {5_mm, 5_mm};
            cvbConfig.layerEnvelopeZ = 1_mm;
            cvbConfig.trackingVolumeHelper = cylinderVolumeHelper;
            cvbConfig.volumeName = "HGTD";
            cvbConfig.layerBuilder = std::move(lb);
            cvbConfig.buildToRadiusZero = false;
 
            Acts::CylinderVolumeBuilder cvb(
                cvbConfig,
                makeActsAthenaLogger(this, std::string("HGTDCylVolBldr"), std::string("ActsTGSvc")));
 
            return cvb.trackingVolume(gctx, inner);
          });
    }
 
    // Calo
    if (m_caloVolumeBuilder.isEnabled()) {
      tgbConfig.trackingVolumeBuilders.push_back(
          [&](const auto &gctx, const auto &inner, const auto &) {
            return m_caloVolumeBuilder->trackingVolume(gctx, inner, nullptr);
          });
    }
 
  } catch (const std::exception &e) {
    ATH_MSG_ERROR("Encountered error when building Acts tracking geometry");
    ATH_MSG_ERROR(e.what());
    return StatusCode::FAILURE;
  }
 
  auto trackingGeometryBuilder =
      std::make_shared<const Acts::TrackingGeometryBuilder>(
          tgbConfig, makeActsAthenaLogger(this, std::string("TrkGeomBldr"), std::string("ActsTGSvc")));
 
  ATH_MSG_VERBOSE("Begin building process");
  m_trackingGeometry =
      trackingGeometryBuilder->trackingGeometry(getNominalContext().context());
  ATH_MSG_VERBOSE("Building process completed");
 
  if (!m_trackingGeometry) {
    ATH_MSG_ERROR("No ACTS tracking geometry was built. Cannot proceeed");
    return StatusCode::FAILURE;
  }
 
 
  if(m_runConsistencyChecks) {
    ATH_MSG_INFO("Running extra consistency check! (this is SLOW)");
    if(!runConsistencyChecks()) {
      ATH_MSG_ERROR("Consistency check has failed! Geometry is not consistent");
      return StatusCode::FAILURE;
    }
  }
 
  m_detIdMap = createDetectorElementToGeoIdMap();
  if (!m_detIdMap) {
      return StatusCode::FAILURE;
  }
 
  if (m_buildDetrayGeometry) {
    ATH_CHECK(buildDetrayGeometry());
  }
 
  ATH_MSG_INFO("Acts TrackingGeometry construction completed");
 
  return StatusCode::SUCCESS;
}

makeBeamPipeConfig()

Acts::CylinderVolumeBuilder::Config ActsTrk::TrackingGeometrySvc::makeBeamPipeConfig ( std::shared_ptr< const Acts::CylinderVolumeHelper > cvh ) const

private

Definition at line 1247 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                             {
 
  // adapted from InnerDetector/InDetDetDescr/InDetTrackingGeometry/src/BeamPipeBuilder.cxx
 
  PVConstLink beamPipeTopVolume =  p_beamPipeMgr->getTreeTop(0);
 
  if (p_beamPipeMgr->getNumTreeTops() == 1){ 
    beamPipeTopVolume = p_beamPipeMgr->getTreeTop(0)->getChildVol(0)->getChildVol(0);
  }
 
  Acts::Transform3 beamPipeTransform;
  beamPipeTransform.setIdentity();
 
  beamPipeTransform = Acts::Translation3(beamPipeTopVolume->getX().translation());
 
  double beamPipeRadius = 20;
 
  const GeoLogVol* beamPipeLogVolume = beamPipeTopVolume->getLogVol();
  const GeoTube* beamPipeTube = nullptr;
 
 
  if (beamPipeLogVolume == nullptr) {
    ATH_MSG_ERROR("Beam pip volume has no log volume");
    throw std::runtime_error("Beam pip volume has no log volume");
  }
  // get the geoShape and translate
  beamPipeTube = dynamic_cast<const GeoTube*>(beamPipeLogVolume->getShape());
  if (beamPipeTube == nullptr){
    ATH_MSG_ERROR("BeamPipeLogVolume was not of type GeoTube");
    throw std::runtime_error{"BeamPipeLogVolume was not of type GeoTube"};
  }
 
  for(unsigned int i=0;i<beamPipeTopVolume->getNChildVols();i++) {
 
    if(beamPipeTopVolume->getNameOfChildVol(i) == "SectionC03"){
 
      PVConstLink childTopVolume =  beamPipeTopVolume->getChildVol(i);
      const GeoLogVol* childLogVolume = childTopVolume->getLogVol();
      const GeoTube* childTube = nullptr;
 
      if (childLogVolume){
        childTube = dynamic_cast<const GeoTube*>(childLogVolume->getShape());
        if (childTube){
          beamPipeRadius = 0.5 * (childTube->getRMax()+childTube->getRMin());
        }
      }
 
      break; // Exit loop after SectionC03 is found
    }
 
  } // Loop over child volumes
 
  ATH_MSG_VERBOSE("BeamPipe constructed from Database: translation (yes) - radius "
      << ( beamPipeTube ? "(yes)" : "(no)") << " - r = " << beamPipeRadius );
 
  ATH_MSG_VERBOSE("BeamPipe shift estimated as    : " << Amg::toString(beamPipeTransform.translation()));
 
  Acts::CylinderVolumeBuilder::Config cfg;
 
  Acts::PassiveLayerBuilder::Config bplConfig;
  bplConfig.layerIdentification = "BeamPipe";
  bplConfig.centralLayerRadii = {beamPipeRadius * 1_mm};
  bplConfig.centralLayerHalflengthZ = {3000_mm};
  bplConfig.centralLayerThickness = {1_mm};
  auto beamPipeBuilder = std::make_shared<const Acts::PassiveLayerBuilder>(
      bplConfig, makeActsAthenaLogger(this, std::string("BPLayBldr"), std::string("ActsTGSvc")));
 
  // create the volume for the beam pipe
  cfg.trackingVolumeHelper = cvh;
  cfg.volumeName = "BeamPipe";
  cfg.layerBuilder = beamPipeBuilder;
  cfg.layerEnvelopeR = {1_mm, 1_mm};
  cfg.buildToRadiusZero = true;
 
  return cfg;
}

makeHGTDLayerBuilder()

std::shared_ptr< const Acts::ILayerBuilder > ActsTrk::TrackingGeometrySvc::makeHGTDLayerBuilder ( const HGTD_DetectorManager * manager )

private

Definition at line 889 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                         {
 
  std::string managerName = manager->getName();
  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
                    Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
                    const Acts::Surface *
                    /*bS*/) -> bool { return false; };
 
  Acts::SurfaceArrayCreator::Config sacCfg;
  sacCfg.surfaceMatcher = matcher;
  sacCfg.doPhiBinningOptimization = false;
 
  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
      sacCfg,
      makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
  Acts::LayerCreator::Config lcCfg;
  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
  auto layerCreator = std::make_shared<Acts::LayerCreator>(
      lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
 
  ActsHGTDLayerBuilder::Config cfg;
  cfg.mng = static_cast<const HGTD_DetectorManager *>(manager);
  cfg.elementStore = m_elementStore;
  cfg.layerCreator = layerCreator;
  cfg.idHelper = m_HGTD_idHelper;
  cfg.numberOfBinsFactor = m_numberOfHgtdBinsFactor;
  return std::make_shared<const ActsHGTDLayerBuilder>(
      cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
}

makeLayerBuilderConfig()

ActsLayerBuilder::Config ActsTrk::TrackingGeometrySvc::makeLayerBuilderConfig ( const InDetDD::InDetDetectorManager * manager )

private

Definition at line 920 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                {
  using enum Acts::AxisDirection;
 
  std::string managerName = manager->getName();
 
  std::shared_ptr<const Acts::ILayerBuilder> gmLayerBuilder;
  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
                    Acts::AxisDirection aDir, const Acts::Surface *aS,
                    const Acts::Surface *bS) -> bool {
    auto* a = getActsDetectorElement(aS);
    auto* b = getActsDetectorElement(bS);
 
    if ((not a) or (not b)) {
      throw std::runtime_error(
          "Cast of surface associated element to ActsDetectorElement failed "
          "in TrackingGeometrySvc::makeVolumeBuilder");
    }
 
    IdentityHelper idA = a->identityHelper();
    IdentityHelper idB = b->identityHelper();
 
    // check if same bec
    // can't be same if not
    if (idA.bec() != idB.bec())
      return false;
 
    if (aDir == AxisPhi) {
      // std::cout << idA.phi_module() << " <-> " << idB.phi_module() <<
      // std::endl;
      return idA.phi_module() == idB.phi_module();
    }
 
    if (aDir == AxisZ) {
      return (idA.eta_module() == idB.eta_module()) &&
             (idA.layer_disk() == idB.layer_disk()) && (idA.bec() == idB.bec());
    }
 
    if (aDir == AxisR) {
      return (idA.eta_module() == idB.eta_module()) &&
             (idA.layer_disk() == idB.layer_disk()) && (idB.bec() == idA.bec());
    }
 
    return false;
  };
 
  Acts::SurfaceArrayCreator::Config sacCfg;
  sacCfg.surfaceMatcher = matcher;
 
  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
      sacCfg,
      makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
  Acts::LayerCreator::Config lcCfg;
  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
  auto layerCreator = std::make_shared<Acts::LayerCreator>(
      lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
 
  ActsLayerBuilder::Config cfg;
  cfg.surfaceMatcher = matcher;
 
  // set bins from configuration
  if (m_barrelMaterialBins.size() != 2) {
    throw std::invalid_argument("Number of barrel material bin counts != 2");
  }
  std::vector<size_t> brlBins(m_barrelMaterialBins);
  cfg.barrelMaterialBins = {brlBins.at(0), brlBins.at(1)};
 
  if (m_endcapMaterialBins.size() != 2) {
    throw std::invalid_argument("Number of endcap material bin counts != 2");
  }
  std::vector<size_t> ecBins(m_endcapMaterialBins);
  cfg.endcapMaterialBins = {ecBins.at(0), ecBins.at(1)};
 
  cfg.mng = static_cast<const InDetDD::SiDetectorManager *>(manager);
  // use class member element store
  cfg.elementStore = m_elementStore;
  cfg.layerCreator = layerCreator;
 
  cfg.numberOfBinsFactor = m_numberOfBinsFactor;
  cfg.surfaceArrayOverfill = static_cast<std::uint8_t>(m_surfaceArrayOverfill.value());
 
  // gmLayerBuilder = std::make_shared<const ActsLayerBuilder>(
  //     cfg, makeActsAthenaLogger(this, managerName + "GMLayBldr",
  //     "ActsTGSvc"));
 
  // return gmLayerBuilder;
  return cfg;
}

makeSCTTRTAssembly()

std::shared_ptr< Acts::TrackingVolume > ActsTrk::TrackingGeometrySvc::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 1010 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                          {
  ATH_MSG_VERBOSE("Building SCT+TRT assembly");
 
  Acts::CylinderVolumeBuilder::Config cvbCfg;
  Acts::CylinderVolumeBuilder cvb(
      cvbCfg, makeActsAthenaLogger(this, std::string("SCTTRTCVB"), std::string("ActsTGSvc")));
 
  ATH_MSG_VERBOSE("Making SCT negative layers: ");
  Acts::VolumeConfig sctNegEC =
      cvb.analyzeContent(gctx, sct_lb.negativeLayers(gctx), {});
  ATH_MSG_VERBOSE("Making SCT positive layers: ");
  Acts::VolumeConfig sctPosEC =
      cvb.analyzeContent(gctx, sct_lb.positiveLayers(gctx), {});
  ATH_MSG_VERBOSE("Making SCT central layers: ");
  Acts::VolumeConfig sctBrl =
      cvb.analyzeContent(gctx, sct_lb.centralLayers(gctx), {});
 
  ATH_MSG_VERBOSE("Making TRT negative layers: ");
  Acts::VolumeConfig trtNegEC =
      cvb.analyzeContent(gctx, trt_lb.negativeLayers(gctx), {});
  ATH_MSG_VERBOSE("Making TRT positive layers: ");
  Acts::VolumeConfig trtPosEC =
      cvb.analyzeContent(gctx, trt_lb.positiveLayers(gctx), {});
  ATH_MSG_VERBOSE("Making TRT central layers: ");
  Acts::VolumeConfig trtBrl =
      cvb.analyzeContent(gctx, trt_lb.centralLayers(gctx), {});
 
  // synchronize trt
 
  double absZMinEC = std::min(std::abs(trtNegEC.zMax), std::abs(trtPosEC.zMin));
  double absZMaxEC = std::max(std::abs(trtNegEC.zMin), std::abs(trtPosEC.zMax));
 
  trtNegEC.zMin = -absZMaxEC;
  trtNegEC.zMax = -absZMinEC;
  trtPosEC.zMin = absZMinEC;
  trtPosEC.zMax = absZMaxEC;
 
  using CVBBV = Acts::CylinderVolumeBounds::BoundValues;
 
  // if pixel is present, shrink SCT volumes in R
  bool isSCTSmallerInZ = false;
  if (pixel) {
    ATH_MSG_VERBOSE("Shrinking SCT in R (and maybe in increase size in Z) to fit around Pixel");
    auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
        &pixel->volumeBounds());
    if (!pixelBounds) {
      throw std::runtime_error(
          "Pixel volume must have cylindrical bounds when building the SCT+TRT assembly");
    }
    double sctNegECzMin = std::min(sctNegEC.zMin, -pixelBounds->get(CVBBV::eHalfLengthZ));
    double sctPosECzMax = std::max(sctPosEC.zMax, pixelBounds->get(CVBBV::eHalfLengthZ));
 
    ATH_MSG_VERBOSE("- SCT +-EC.rMin: " << sctNegEC.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
    ATH_MSG_VERBOSE("- SCT  BRL.rMin: " << sctBrl.rMin << " -> " << pixelBounds->get(CVBBV::eMaxR));
    ATH_MSG_VERBOSE("- SCT EC.zMin: " << sctNegEC.zMin << " -> " << sctNegECzMin);
    ATH_MSG_VERBOSE("- SCT EC.zMax: " << sctPosEC.zMax << " -> " << sctPosECzMax);
 
    sctNegEC.rMin = pixelBounds->get(CVBBV::eMaxR);
    sctPosEC.rMin = pixelBounds->get(CVBBV::eMaxR);
    sctBrl.rMin = pixelBounds->get(CVBBV::eMaxR);
 
    isSCTSmallerInZ = sctPosEC.zMax < pixelBounds->get(CVBBV::eHalfLengthZ);
 
    sctNegEC.zMin = sctNegECzMin;
    sctPosEC.zMax = sctPosECzMax;
 
 
  } else {
    ATH_MSG_VERBOSE("Pixel is not configured, not wrapping");
  }
 
  ATH_MSG_VERBOSE("SCT Volume Configuration:");
  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
                                            << " layers, "
                                            << sctNegEC.toString());
  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
                                    << sctBrl.toString());
  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
                                           << " layers, "
                                           << sctPosEC.toString());
 
  ATH_MSG_VERBOSE("TRT Volume Configuration:");
  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
                                            << " layers, "
                                            << trtNegEC.toString());
  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
                                    << trtBrl.toString());
  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
                                           << " layers, "
                                           << trtPosEC.toString());
 
  // harmonize SCT BRL <-> EC, normally the CVB does this, but we're skipping
  // that
  sctBrl.zMax = (sctBrl.zMax + sctPosEC.zMin) / 2.;
  sctBrl.zMin = -sctBrl.zMax;
 
  // and now harmonize everything
  // inflate TRT Barrel to match SCT
  trtBrl.zMin = sctBrl.zMin;
  trtBrl.zMax = sctBrl.zMax;
 
  // extend TRT endcaps outwards z so they match SCT
  trtNegEC.zMin = sctNegEC.zMin;
  trtPosEC.zMax = sctPosEC.zMax;
 
  // extend endcap in z so it touches barrel
  trtNegEC.zMax = trtBrl.zMin;
  sctNegEC.zMax = trtBrl.zMin;
  trtPosEC.zMin = trtBrl.zMax;
  sctPosEC.zMin = trtBrl.zMax;
 
  // extend SCT in R so they touch TRT barel
  sctBrl.rMax = trtBrl.rMin;
  sctNegEC.rMax = trtNegEC.rMin;
  sctPosEC.rMax = trtPosEC.rMin;
 
  // extend TRT endcaps in r to that of Barrel
  trtNegEC.rMax = trtBrl.rMax;
  trtPosEC.rMax = trtBrl.rMax;
 
  ATH_MSG_VERBOSE("Dimensions after synchronization between SCT and TRT");
  ATH_MSG_VERBOSE("SCT Volume Configuration:");
  ATH_MSG_VERBOSE("- SCT::NegativeEndcap: " << sctNegEC.layers.size()
                                            << " layers, "
                                            << sctNegEC.toString());
  ATH_MSG_VERBOSE("- SCT::Barrel: " << sctBrl.layers.size() << " layers, "
                                    << sctBrl.toString());
  ATH_MSG_VERBOSE("- SCT::PositiveEncap: " << sctPosEC.layers.size()
                                           << " layers, "
                                           << sctPosEC.toString());
 
  ATH_MSG_VERBOSE("TRT Volume Configuration:");
  ATH_MSG_VERBOSE("- TRT::NegativeEndcap: " << trtNegEC.layers.size()
                                            << " layers, "
                                            << trtNegEC.toString());
  ATH_MSG_VERBOSE("- TRT::Barrel: " << trtBrl.layers.size() << " layers, "
                                    << trtBrl.toString());
  ATH_MSG_VERBOSE("- TRT::PositiveEncap: " << trtPosEC.layers.size()
                                           << " layers, "
                                           << trtPosEC.toString());
 
  auto makeTVol = [&](const auto &vConf, const auto &name) {
    return cvh.createTrackingVolume(gctx, vConf.layers, {},
                                    nullptr, // no material
                                    vConf.rMin, vConf.rMax, vConf.zMin,
                                    vConf.zMax, name);
  };
 
  // now turn them into actual TrackingVolumes
  auto tvSctNegEC = makeTVol(sctNegEC, "SCT::NegativeEndcap");
  auto tvSctBrl = makeTVol(sctBrl, "SCT::Barrel");
  auto tvSctPosEC = makeTVol(sctPosEC, "SCT::PositiveEndcap");
 
  auto tvTrtNegEC = makeTVol(trtNegEC, "TRT::NegativeEndcap");
  auto tvTrtBrl = makeTVol(trtBrl, "TRT::Barrel");
  auto tvTrtPosEC = makeTVol(trtPosEC, "TRT::PositiveEndcap");
 
  // combine the endcaps and the barrels, respetively
  auto negEC =
      cvh.createContainerTrackingVolume(gctx, {tvSctNegEC, tvTrtNegEC});
  auto posEC =
      cvh.createContainerTrackingVolume(gctx, {tvSctPosEC, tvTrtPosEC});
  auto barrel = cvh.createContainerTrackingVolume(gctx, {tvSctBrl, tvTrtBrl});
 
  // and now combine all of those into one container for the assembly
 
  auto container =
      cvh.createContainerTrackingVolume(gctx, {negEC, barrel, posEC});
 
  // if pixel is present, add positive and negative gap volumes so we can wrap
  // it all
  if (pixel) {
    auto containerBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
        &container->volumeBounds());
    if (!containerBounds) {
      throw std::runtime_error(
          "SCT+TRT container volume must have cylindrical bounds when wrapping Pixel");
    }
    auto pixelBounds = dynamic_cast<const Acts::CylinderVolumeBounds *>(
        &pixel->volumeBounds());
    if (!pixelBounds) {
      throw std::runtime_error(
          "Pixel volume must have cylindrical bounds when wrapping it with the SCT+TRT assembly");
    }
    std::vector<std::shared_ptr<Acts::TrackingVolume>> noVolumes;
 
    if(!isSCTSmallerInZ) {
      // pixel is smaller in z, need gap volumes
      auto posGap = cvh.createGapTrackingVolume(
          gctx, noVolumes,
          nullptr, // no material,
          pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
          pixelBounds->get(CVBBV::eHalfLengthZ),
          containerBounds->get(CVBBV::eHalfLengthZ),
          0,    // material layers,
          true, // cylinder
          "Pixel::PositiveGap");
      auto negGap = cvh.createGapTrackingVolume(
          gctx, noVolumes,
          nullptr, // no material,
          pixelBounds->get(CVBBV::eMinR), pixelBounds->get(CVBBV::eMaxR),
          -containerBounds->get(CVBBV::eHalfLengthZ),
          -pixelBounds->get(CVBBV::eHalfLengthZ),
          0,    // material layers,
          true, // cylinder
          "Pixel::NegativeGap");
 
      auto pixelContainer =
          cvh.createContainerTrackingVolume(gctx, {negGap, pixel, posGap});
      // and now create one container that contains Pixel+SCT+TRT
      container =
          cvh.createContainerTrackingVolume(gctx, {pixelContainer, container});
    }
    else {
      // wrap the pixel directly
      container =
          cvh.createContainerTrackingVolume(gctx, {pixel, container});
    }
 
  }
 
  return container;
}

makeStrawLayerBuilder()

std::shared_ptr< const Acts::ILayerBuilder > ActsTrk::TrackingGeometrySvc::makeStrawLayerBuilder ( const InDetDD::InDetDetectorManager * manager )

private

Definition at line 858 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                {
 
  std::string managerName = manager->getName();
  auto matcher = [](const Acts::GeometryContext & /*gctx*/,
                    Acts::AxisDirection /*aDir*/, const Acts::Surface * /*aS*/,
                    const Acts::Surface *
                    /*bS*/) -> bool { return false; };
 
  Acts::SurfaceArrayCreator::Config sacCfg;
  sacCfg.surfaceMatcher = matcher;
  sacCfg.doPhiBinningOptimization = false;
 
  auto surfaceArrayCreator = std::make_shared<Acts::SurfaceArrayCreator>(
      sacCfg,
      makeActsAthenaLogger(this, managerName + "SrfArrCrtr", std::string("ActsTGSvc")));
  Acts::LayerCreator::Config lcCfg;
  lcCfg.surfaceArrayCreator = surfaceArrayCreator;
  auto layerCreator = std::make_shared<Acts::LayerCreator>(
      lcCfg, makeActsAthenaLogger(this, managerName + "LayCrtr", std::string("ActsTGSvc")));
 
  ActsStrawLayerBuilder::Config cfg;
  cfg.mng = static_cast<const InDetDD::TRT_DetectorManager *>(manager);
  cfg.elementStore = m_elementStore;
  cfg.layerCreator = layerCreator;
  cfg.idHelper = m_TRT_idHelper;
  return std::make_shared<const ActsStrawLayerBuilder>(
      cfg, makeActsAthenaLogger(this, managerName + "GMSLayBldr", std::string("ActsTGSvc")));
}

populateAlignmentStore()

unsigned int ActsTrk::TrackingGeometrySvc::populateAlignmentStore ( ActsTrk::DetectorAlignStore & store ) const

override

Loops through the volumes of the tracking geometry and caches the aligned transforms in the store.

Definition at line 1237 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                                                        {
    ATH_MSG_DEBUG("Populate the alignment store with all detector elements");
    TrackingGeoAlignVisitor visitor{store};
    m_trackingGeometry->apply(visitor);
    ATH_MSG_DEBUG("Populated with " << visitor.alignedObjects() << " elements");
    return visitor.alignedObjects();
}

runConsistencyChecks()

bool ActsTrk::TrackingGeometrySvc::runConsistencyChecks ( ) const

private

Definition at line 625 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                     {
  bool result = true;
 
  std::vector<Acts::Vector2> localPoints;
  localPoints.reserve(m_consistencyCheckPoints);
  std::mt19937 gen;
  std::uniform_real_distribution<> dist(0.0, 1.0);
 
  std::optional<std::ofstream> os;
  if(!m_consistencyCheckOutput.empty()){
    os = std::ofstream{m_consistencyCheckOutput};
    if(!os->good()) {
      throw std::runtime_error{"Failed to open consistency check output file"};
    }
  }
 
  if(os) {
    (*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;
  }
  for(size_t i=0;i<m_consistencyCheckPoints;i++) {
    localPoints.emplace_back(dist(gen), dist(gen));
  }
 
  Acts::GeometryContext gctx = getNominalContext().context();
 
  size_t nTotalSensors = 0;
  std::array<size_t,3> nInconsistent{0,0,0};
  size_t nMismatchedCenters = 0;
  size_t nMismatchedNormals = 0;
 
  // Comparison of Eigen vectors, similar to a.isApprox(b), but use absolute comparison to also work with zero vectors.
  // All values will be mm or radians, so 1e-5 is a reasonable precision.
  auto isApprox = [](auto& a, auto& b) -> bool {
    return ((a - b).array().abs() < 1e-5).all();
  };
 
  m_trackingGeometry->visitSurfaces([&](const Acts::Surface *surface) {
      nTotalSensors++;
      const auto* actsDetElem = getActsDetectorElement(surface);
      if(actsDetElem == nullptr) {
        ATH_MSG_ERROR("Invalid detector element found");
        result = false;
        return;
      }
      const auto* siDetElem = dynamic_cast<const InDetDD::SiDetectorElement*>(actsDetElem->upstreamDetectorElement());
      if(siDetElem  == nullptr) {
        return;
      }
 
      const auto* regSurface = dynamic_cast<const Acts::RegularSurface*>(surface);
      const auto& trkSurface = siDetElem->surface();
      if(regSurface == nullptr) {
        ATH_MSG_ERROR("Invalid surface found");
        result = false;
        return;
      }
 
      Acts::Vector3 center{regSurface->center(gctx)};
      Amg::Vector3D trkCenter{trkSurface.center()};
      if (/* auto *b = */ dynamic_cast<const Acts::AnnulusBounds *>(&surface->bounds()))
      {
        // // Acts::AnnulusBounds defines center() as center of whole disc, so get it from the bounds
        // Acts::Vector2 locCenter{0.5 * (b->rMin() + b->rMax()), 0.5 * (b->phiMin() + b->phiMax())};
        // center = surface->localToGlobal(gctx, locCenter, Acts::Vector3::Zero());
        center.head<2>() = trkCenter.head<2>();  // that doesn't (quite) work for xy, so just pass that check
      }
 
      if(!isApprox(trkCenter, center)) {
        std::string trkName;
        if (auto idHelper = siDetElem->getIdHelper())
        {
          trkName = idHelper->show_to_string(siDetElem->identify());
        }
        ATH_MSG_WARNING("Acts surface "
                        << surface->geometryId()
                        << " center (" << center[0] << ',' << center[1] << ',' << center[2]
                        << ") does not match Trk surface " << trkName
                        << " center (" << trkCenter[0] << ',' << trkCenter[1] << ',' << trkCenter[2] << ')');
        nMismatchedCenters++;
        result = false;
      }
 
      const auto* lineSurface = dynamic_cast<const Acts::LineSurface*>(surface);
      if(lineSurface == nullptr) {
        Acts::Vector3 norm{regSurface->normal(gctx, regSurface->center(gctx))};
        Amg::Vector3D trkNorm{trkSurface.normal()};
        if(!isApprox(trkNorm, norm)) {
          std::string trkName;
          if (auto idHelper = siDetElem->getIdHelper())
          {
            trkName = idHelper->show_to_string(siDetElem->identify());
          }
          ATH_MSG_WARNING("Acts surface "
                          << surface->geometryId()
                          << " normal (" << norm[0] << ',' << norm[1] << ',' << norm[2]
                          << ") does not match Trk surface " << trkName
                          << " normal (" << trkNorm[0] << ',' << trkNorm[1] << ',' << trkNorm[2] << ')');
          nMismatchedNormals++;
          result = false;
        }
      }
 
      auto doPoints = [&](unsigned int type, const Acts::Vector2& loc) -> std::array<bool,3> {
          Acts::Vector3 glb = surface->localToGlobal(gctx, loc, Acts::Vector3::Zero());
 
          Amg::Vector2D locTrk = Amg::Vector2D::Zero();
          Amg::Vector3D glbTrk = Amg::Vector3D::Zero();
          Acts::Vector2 locg2l = Acts::Vector2::Zero();
          bool locg2lOk = false;
          auto locTrkRes = trkSurface.globalToLocal(glb);
          if (locTrkRes) {
            locTrk = locTrkRes.value();
            glbTrk = trkSurface.localToGlobal(locTrk);
 
            auto locg2lRes = surface->globalToLocal(gctx, glbTrk, Acts::Vector3::Zero());
            if (locg2lRes.ok()) {
              locg2lOk = true;
              locg2l = locg2lRes.value();
            }
          }
 
          auto gId = surface->geometryId();
          if(os) {
            (*os) << gId.value() 
                  << "," << gId.volume()
                  << "," << gId.layer()
                  << "," << gId.sensitive()
                  << "," << type
                  << "," << loc[0] 
                  << "," << loc[1] 
                  << "," << surface->insideBounds(loc)
                  << "," << locTrk[0] 
                  << "," << locTrk[1] 
                  << "," << trkSurface.insideBounds(locTrk)
                  << "," << glb[0] 
                  << "," << glb[1] 
                  << "," << glb[2] 
                  << "," << locg2l[0] 
                  << "," << locg2l[1] 
                  << "," << glbTrk[0] 
                  << "," << glbTrk[1] 
                  << "," << glbTrk[2] 
                  << std::endl;
          }
 
          return {surface->insideBounds(loc) == trkSurface.insideBounds(locTrk),
                  locg2lOk ? isApprox(loc, locg2l) : true,
                  locTrkRes ? isApprox(glb, glbTrk) : true};
      };
 
 
      constexpr double envelope = 10.0 * Acts::UnitConstants::mm;
 
      std::array<bool,3> allOk{true,true,true};
      if(const auto* bounds = dynamic_cast<const Acts::PlanarBounds*>(&surface->bounds()); bounds) {
        ATH_MSG_VERBOSE("Planar bounds");
 
        const Acts::RectangleBounds& boundingBox = bounds->boundingBox();
        Acts::Vector2 min = boundingBox.min().array() - envelope;
        Acts::Vector2 max = boundingBox.max().array() + envelope;
        Acts::Vector2 diag = max - min;
 
        for(const auto& testPoint : localPoints) {
          Acts::Vector2 loc = min.array() + (testPoint.array() * diag.array());
          auto pointOk = doPoints(0, loc);
          for (size_t i=0; i<pointOk.size(); ++i) {
            if (!pointOk[i]) {
              result = false;
              allOk[i] = false;
            }
          }
        }
 
      }
      else if(const auto* bounds = dynamic_cast<const Acts::AnnulusBounds*>(&surface->bounds()); bounds) {
        ATH_MSG_VERBOSE("Annulus bounds");
 
        // custom bounding box algo
        std::vector<Acts::Vector2> vertices = bounds->vertices(5); // 5 segments on the radial edges
        Acts::Vector2 min{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
        Acts::Vector2 max{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest()};
        for (const auto& vtx : vertices) {
          min = min.array().min(vtx.array());
          max = max.array().max(vtx.array());
        }
        min.array() -= envelope;
        max.array() += envelope;
        Acts::Vector2 diag = max - min;
 
        for(const auto& testPoint : localPoints) {
          Acts::Vector2 locXY = min.array() + (testPoint.array() * diag.array());
          Acts::Vector2 locPC = dynamic_cast<const Acts::DiscSurface&>(*surface).localCartesianToPolar(locXY);
 
          auto pointOk = doPoints(1, locPC);
          for (size_t i=0; i<pointOk.size(); ++i) {
            if (!pointOk[i]) {
              result = false;
              allOk[i] = false;
            }
          }
        }
 
      }
      else {
        result = false;
      }
 
      for (size_t i=0; i<allOk.size(); ++i) {
        if (!allOk[i]) {
          ++nInconsistent[i];
        }
      }
 
  });
 
  ATH_MSG_INFO("Total number of sensors                   : " << nTotalSensors);
  ATH_MSG_INFO("Number of sensors with mismatched centers : " << nMismatchedCenters);
  ATH_MSG_INFO("Number of sensors with mismatched normals : " << nMismatchedNormals);
  ATH_MSG_INFO("Number of sensors with inconsistent inside: " << nInconsistent[0]);
  ATH_MSG_INFO("Number of sensors with inconsistent g2l   : " << nInconsistent[1]);
  ATH_MSG_INFO("Number of sensors with inconsistent l2g   : " << nInconsistent[2]);
 
  return result;
}

surfaceIdMap()

const ActsTrk::DetectorElementToActsGeometryIdMap * ActsTrk::TrackingGeometrySvc::surfaceIdMap ( ) const

overridevirtual

Returns the pointer to the identifier mapping between Acts::surface ID & IdentifierHash of the ITk surfaces.

Definition at line 622 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                                                                         {
  return m_detIdMap.get();
}

trackingGeometry()

std::shared_ptr< const Acts::TrackingGeometry > ActsTrk::TrackingGeometrySvc::trackingGeometry ( ) const

override

Returns a pointer to the internal ACTS tracking geometry.

Definition at line 851 of file Acts/ActsGeometry/src/TrackingGeometrySvc.cxx.

                                            {
 
  ATH_MSG_VERBOSE("Retrieving tracking geometry");
  return m_trackingGeometry;
}

Member Data Documentation

m_barrelMaterialBins

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

private

Definition at line 141 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "BarrelMaterialBins", {10, 10}};

m_blueprintGraphviz

Gaudi::Property<std::string> ActsTrk::TrackingGeometrySvc::m_blueprintGraphviz

private

Initial value:

{this, "BlueprintGraphviz", 
                                                   "", "Write the blueprint graph to a file. No file will be written if empty"}

Definition at line 205 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                              {this, "BlueprintGraphviz", 
                                                   "", "Write the blueprint graph to a file. No file will be written if empty"};

m_blueprintNodeBuilders

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

private

Definition at line 172 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "BlueprintNodeBuilders", {}};

m_buildBeamPipe

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_buildBeamPipe {this, "BuildBeamPipe", false, ""}

private

Definition at line 136 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "BuildBeamPipe", false, ""};

m_buildDetrayGeometry

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_buildDetrayGeometry

private

Initial value:

{this, "BuildDetrayGeometry", false,
      "Convert the constructed Acts::TrackingGeometry into a Detray geometry."}

Definition at line 181 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                           {this, "BuildDetrayGeometry", false,
      "Convert the constructed Acts::TrackingGeometry into a Detray geometry."};

m_buildDetrayMaterial

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_buildDetrayMaterial

private

Initial value:

{this, "BuildDetrayMaterial", true,
      "Build the Detray material from the volume navigation policies. "
      "Only used when BuildDetrayGeometry is enabled."}

Definition at line 192 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                           {this, "BuildDetrayMaterial", true,
      "Build the Detray material from the volume navigation policies. "
      "Only used when BuildDetrayGeometry is enabled."};    

m_buildDetraySurfaceGrids

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_buildDetraySurfaceGrids

private

Initial value:

{this, "BuildDetraySurfaceGrids", true,
      "Build the Detray surface grids from the volume navigation policies. "
      "Only used when BuildDetrayGeometry is enabled."}

Definition at line 188 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                               {this, "BuildDetraySurfaceGrids", true,
      "Build the Detray surface grids from the volume navigation policies. "
      "Only used when BuildDetrayGeometry is enabled."};

m_buildSubdetectors

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

private

Definition at line 143 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "BuildSubDetectors", {"Pixel", "SCT", "TRT", "Calo", "HGTD", "Muon"}};

m_caloVolumeBuilder

ToolHandle<IActsTrackingVolumeBuilder> ActsTrk::TrackingGeometrySvc::m_caloVolumeBuilder {this, "CaloVolumeBuilder", ""}

private

Definition at line 170 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "CaloVolumeBuilder", ""};

m_checkDetrayGeometry

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_checkDetrayGeometry

private

Initial value:

{this, "CheckDetrayGeometry", false,
      "Run the Detray consistency check on the converted geometry. "
      "Only used when BuildDetrayGeometry is enabled."}

Definition at line 184 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                           {this, "CheckDetrayGeometry", false,
      "Run the Detray consistency check on the converted geometry. "
      "Only used when BuildDetrayGeometry is enabled."};

m_consistencyCheckOutput

StringProperty ActsTrk::TrackingGeometrySvc::m_consistencyCheckOutput

private

Initial value:

{this, "ConsistencyCheckOutput", 
    "", "Output file for geometry debugging, will not write if empty",}

Definition at line 164 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                         {this, "ConsistencyCheckOutput", 
    "", "Output file for geometry debugging, will not write if empty",};

m_consistencyCheckPoints

Gaudi::Property<size_t> ActsTrk::TrackingGeometrySvc::m_consistencyCheckPoints

private

Initial value:

{this, "ConsistencyCheckPoints",
    1000, "number of random points for consistency check"}

Definition at line 167 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                {this, "ConsistencyCheckPoints",
    1000, "number of random points for consistency check"};

m_detIdMap

std::unique_ptr<const ActsTrk::DetectorElementToActsGeometryIdMap> ActsTrk::TrackingGeometrySvc::m_detIdMap {}

private

Definition at line 245 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{};

m_detrayGeometry

std::unique_ptr<traccc::host_detector> ActsTrk::TrackingGeometrySvc::m_detrayGeometry

private

Definition at line 247 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

m_detStore

ServiceHandle<StoreGateSvc> ActsTrk::TrackingGeometrySvc::m_detStore

private

Definition at line 114 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

m_doEndcapLayerMerging

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

private

Definition at line 207 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "DoEndcapLayerMerging", true, "Merge overlapping endcap layers in z"};

m_elementStore

std::shared_ptr<ActsElementVector> ActsTrk::TrackingGeometrySvc::m_elementStore {nullptr}

private

Definition at line 123 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

m_endcapMaterialBins

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

private

Definition at line 142 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "EndcapMaterialBins", {5, 20}};

m_HGTD_idHelper

const HGTD_ID* ActsTrk::TrackingGeometrySvc::m_HGTD_idHelper {nullptr}

private

Definition at line 127 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

m_hostMR

ToolHandle<AthDevice::IMemoryResourceTool> ActsTrk::TrackingGeometrySvc::m_hostMR

private

Initial value:

{this, "HostMR", "",
      "Host memory resource tool used for the Detray geometry allocations. The "
      "conversion runs entirely on the host, so the resource has to be host "
      "accessible: a plain host or a managed/shared one, not a device one."}

Tool providing the memory resource that the Detray geometry is allocated from.

The detector keeps referring to that resource for its deallocations, so the tool has to outlive m_detrayGeometry. Only used, and only required to be set, when BuildDetrayGeometry is enabled.

Definition at line 200 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                   {this, "HostMR", "",
      "Host memory resource tool used for the Detray geometry allocations. The "
      "conversion runs entirely on the host, so the resource has to be host "
      "accessible: a plain host or a managed/shared one, not a device one."};

m_itkPixelInnerBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkPixelInnerBarrelNeighborWindow

private

Initial value:

{
      this, "ITkPixelInnerBarrelNeighborWindow", {1, 8},
      "Neighbor window bound {phi, z} of the ITk inner pixel barrel layers"}

Most bins the surface array lookup serves on each side of the crossing, as {phi, z} for the barrel and {r, phi} for the endcap.

The lookup sizes the window from the crossing angle and the layer thickness, so these values only cap it. The defaults cover the steepest crossing for |z0| < 200 mm at NumberOfBinsFactor = 5.

Definition at line 219 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                            {
      this, "ITkPixelInnerBarrelNeighborWindow", {1, 8},
      "Neighbor window bound {phi, z} of the ITk inner pixel barrel layers"};

m_itkPixelInnerEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkPixelInnerEndcapNeighborWindow

private

Initial value:

{
      this, "ITkPixelInnerEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk inner pixel endcap layers"}

Definition at line 222 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                            {
      this, "ITkPixelInnerEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk inner pixel endcap layers"};

m_itkPixelOuterBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkPixelOuterBarrelNeighborWindow

private

Initial value:

{
      this, "ITkPixelOuterBarrelNeighborWindow", {1, 3},
      "Neighbor window bound {phi, z} of the ITk outer pixel barrel layers"}

Definition at line 225 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                            {
      this, "ITkPixelOuterBarrelNeighborWindow", {1, 3},
      "Neighbor window bound {phi, z} of the ITk outer pixel barrel layers"};

m_itkPixelOuterEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkPixelOuterEndcapNeighborWindow

private

Initial value:

{
      this, "ITkPixelOuterEndcapNeighborWindow", {4, 1},
      "Neighbor window bound {r, phi} of the ITk outer pixel endcap and inclined layers"}

Definition at line 228 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                            {
      this, "ITkPixelOuterEndcapNeighborWindow", {4, 1},
      "Neighbor window bound {r, phi} of the ITk outer pixel endcap and inclined layers"};

m_itkStripBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkStripBarrelNeighborWindow

private

Initial value:

{
      this, "ITkStripBarrelNeighborWindow", {1, 4},
      "Neighbor window bound {phi, z} of the ITk strip barrel layers"}

Definition at line 231 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                       {
      this, "ITkStripBarrelNeighborWindow", {1, 4},
      "Neighbor window bound {phi, z} of the ITk strip barrel layers"};

m_itkStripEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackingGeometrySvc::m_itkStripEndcapNeighborWindow

private

Initial value:

{
      this, "ITkStripEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk strip endcap layers"}

Definition at line 234 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                                       {
      this, "ITkStripEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk strip endcap layers"};

m_keepGoingOnMaterialMergeFailure

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_keepGoingOnMaterialMergeFailure {this, "KeepGoingOnMaterialMergeFailure", false, ""}

private

Definition at line 133 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "KeepGoingOnMaterialMergeFailure", false, ""};

m_materialMapCalibFolder

Gaudi::Property<std::string> ActsTrk::TrackingGeometrySvc::m_materialMapCalibFolder {this, "MaterialMapCalibFolder", ".", ""}

private

Definition at line 135 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "MaterialMapCalibFolder", ".", ""};

m_materialMapInputFileBase

Gaudi::Property<std::string> ActsTrk::TrackingGeometrySvc::m_materialMapInputFileBase {this, "MaterialMapInputFile", "", ""}

private

Definition at line 134 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "MaterialMapInputFile", "", ""};

m_nominalContext

ActsTrk::GeometryContext ActsTrk::TrackingGeometrySvc::m_nominalContext {}

private

Definition at line 129 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{};

m_numberOfBinsFactor

Gaudi::Property<double> ActsTrk::TrackingGeometrySvc::m_numberOfBinsFactor {this, "NumberOfBinsFactor", 5.0}

private

controls how many bins are created for the sensitive surface grid.

1 results in the same number of bins as there are surfaces per layer in each dimension. using a higher number will reduce the number of surfaces per bin, thus speeding up navigation, but increasing memory consumption.

Definition at line 212 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "NumberOfBinsFactor", 5.0};

m_numberOfHgtdBinsFactor

Gaudi::Property<double> ActsTrk::TrackingGeometrySvc::m_numberOfHgtdBinsFactor {this, "NumberOfHgtdBinsFactor", 5.0}

private

Special treatment for hgtd layers as well.

Definition at line 243 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "NumberOfHgtdBinsFactor", 5.0};

m_objDebugOutput

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_objDebugOutput {this, "ObjDebugOutput", false, ""}

private

Definition at line 132 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "ObjDebugOutput", false, ""};

m_passiveITkInnerPixelBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerHalflengthZ {this, "PassiveITkInnerPixelBarrelLayerHalflengthZ", {}}

private

Definition at line 150 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkInnerPixelBarrelLayerHalflengthZ", {}};

m_passiveITkInnerPixelBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::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 149 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkInnerPixelBarrelLayerRadii", {}};

m_passiveITkInnerPixelBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkInnerPixelBarrelLayerThickness {this, "PassiveITkInnerPixelBarrelLayerThickness", {}}

private

Definition at line 151 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkInnerPixelBarrelLayerThickness", {}};

m_passiveITkOuterPixelBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerHalflengthZ {this, "PassiveITkOuterPixelBarrelLayerHalflengthZ", {}}

private

Definition at line 154 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkOuterPixelBarrelLayerHalflengthZ", {}};

m_passiveITkOuterPixelBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerRadii {this, "PassiveITkOuterPixelBarrelLayerRadii", {}}

private

Definition at line 153 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkOuterPixelBarrelLayerRadii", {}};

m_passiveITkOuterPixelBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkOuterPixelBarrelLayerThickness {this, "PassiveITkOuterPixelBarrelLayerThickness", {}}

private

Definition at line 155 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkOuterPixelBarrelLayerThickness", {}};

m_passiveITkStripBarrelLayerHalflengthZ

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkStripBarrelLayerHalflengthZ {this, "PassiveITkStripBarrelLayerHalflengthZ", {}}

private

Definition at line 158 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkStripBarrelLayerHalflengthZ", {}};

m_passiveITkStripBarrelLayerRadii

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkStripBarrelLayerRadii {this, "PassiveITkStripBarrelLayerRadii", {}}

private

Definition at line 157 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkStripBarrelLayerRadii", {}};

m_passiveITkStripBarrelLayerThickness

Gaudi::Property<std::vector<float> > ActsTrk::TrackingGeometrySvc::m_passiveITkStripBarrelLayerThickness {this, "PassiveITkStripBarrelLayerThickness", {}}

private

Definition at line 159 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "PassiveITkStripBarrelLayerThickness", {}};

m_printGeo

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_printGeo {this, "printGeometry", false}

private

Print the assembled tracking geometry after building.

Definition at line 139 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "printGeometry", false};

m_refineVisitors

ToolHandleArray<ActsTrk::IRefineTrackingGeoTool> ActsTrk::TrackingGeometrySvc::m_refineVisitors {this, "RefinementTools", {}}

private

Definition at line 174 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "RefinementTools", {}};

m_runConsistencyChecks

BooleanProperty ActsTrk::TrackingGeometrySvc::m_runConsistencyChecks

private

Initial value:

{this, "RunConsistencyChecks", 
    false, "Run extra consistency checks w.r.t to Trk::. This is SLOW!"}

Definition at line 161 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                        {this, "RunConsistencyChecks", 
    false, "Run extra consistency checks w.r.t to Trk::. This is SLOW!"};

m_subDetNoAlign

std::set<ActsTrk::DetectorType> ActsTrk::TrackingGeometrySvc::m_subDetNoAlign {}

private

Definition at line 177 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{};

m_subDetNoAlignProp

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

private

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

Definition at line 176 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "NotAlignDetectors", {}};

m_surfaceArrayOverfill

Gaudi::Property<unsigned int> ActsTrk::TrackingGeometrySvc::m_surfaceArrayOverfill

private

Initial value:

{this, "SurfaceArrayOverfill", 0,
      "Extra cells per direction and axis that each surface fills in the surface arrays"}

Extra cells per direction and axis that each surface fills around its footprint.

Definition at line 239 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

                                                    {this, "SurfaceArrayOverfill", 0,
      "Extra cells per direction and axis that each surface fills in the surface arrays"};

m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> ActsTrk::TrackingGeometrySvc::m_trackingGeometry {nullptr}

private

Definition at line 124 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

m_TRT_idHelper

const TRT_ID* ActsTrk::TrackingGeometrySvc::m_TRT_idHelper {nullptr}

private

Definition at line 126 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

m_useBlueprint

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

private

Definition at line 179 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "UseBlueprint", false, "Use the new Blueprint API for geometry construction"};

m_useMaterialMap

Gaudi::Property<bool> ActsTrk::TrackingGeometrySvc::m_useMaterialMap {this, "UseMaterialMap", false, ""}

private

Definition at line 131 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{this, "UseMaterialMap", false, ""};

p_beamPipeMgr

const BeamPipeDetectorManager* ActsTrk::TrackingGeometrySvc::p_beamPipeMgr {nullptr}

private

Definition at line 120 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_HGTDManager

const HGTD_DetectorManager* ActsTrk::TrackingGeometrySvc::p_HGTDManager {nullptr}

private

Definition at line 121 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_ITkPixelManager

const InDetDD::SiDetectorManager* ActsTrk::TrackingGeometrySvc::p_ITkPixelManager {nullptr}

private

Definition at line 118 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_ITkStripManager

const InDetDD::SiDetectorManager* ActsTrk::TrackingGeometrySvc::p_ITkStripManager {nullptr}

private

Definition at line 119 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_pixelManager

const InDetDD::SiDetectorManager* ActsTrk::TrackingGeometrySvc::p_pixelManager {nullptr}

private

Definition at line 115 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_SCTManager

const InDetDD::SiDetectorManager* ActsTrk::TrackingGeometrySvc::p_SCTManager {nullptr}

private

Definition at line 116 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

p_TRTManager

const InDetDD::TRT_DetectorManager* ActsTrk::TrackingGeometrySvc::p_TRTManager {nullptr}

private

Definition at line 117 of file Acts/ActsGeometry/src/TrackingGeometrySvc.h.

{nullptr};

---

The documentation for this class was generated from the following files:

• Acts/ActsGeometry/src/TrackingGeometrySvc.h
• Acts/ActsGeometry/src/TrackingGeometrySvc.cxx