ActsTrk::GeometryRealmConvTool Class Reference

Implementation of the IGeometryRealmConvTool. More...

#include <GeometryRealmConvTool.h>

Inheritance diagram for ActsTrk::GeometryRealmConvTool:

Collaboration diagram for ActsTrk::GeometryRealmConvTool:

Public Member Functions
	~GeometryRealmConvTool ()
virtual StatusCode	initialize () override final
virtual SurfacePtr_t	convertSurfaceToTrk (const EventContext &ctx, const Acts::Surface &actsSurface) const override final
	Translates the parsed Acts surface into a Trk::Surface via associated detector element.
virtual std::shared_ptr< const Acts::Surface >	convertSurfaceToActs (const Trk::Surface &atlasSurface) const override final
	Translate the parsed Trk surface into an Acts surface.
virtual Acts::BoundTrackParameters	convertTrackParametersToActs (const EventContext &ctx, const Trk::TrackParameters &atlasParameter, Trk::ParticleHypothesis hypothesis=Trk::pion) const override final
	Translates the Trk track parameters into bound Acts track parameters with a particle hypothesis.
virtual std::unique_ptr< Trk::TrackParameters >	convertTrackParametersToTrk (const EventContext &ctx, const Acts::BoundTrackParameters &actsParameters) const override final
	Translates the bounded Acts track parameters to Trk parameters.

Private Member Functions
std::shared_ptr< Trk::SurfaceBounds >	translateBounds (const Acts::SurfaceBounds &bounds) const
	Translate the Acts surface bounds to its equivalent in the Trk realm.
SurfacePtr_t	translateFreeSurface (const EventContext &ctx, const Acts::Surface &surface) const
	Translate a surface that is not associated with any detector element.

Private Attributes
PublicToolHandle< ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry {}
std::unordered_map< Identifier, std::shared_ptr< const Acts::Surface > >	m_actsSurfaceMap {}
Gaudi::Property< bool >	m_extractMuonSurfaces
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muonMgrKey {this, "MuonManagerKey", "MuonDetectorManager"}
	Detector manager to fetch the legacy Trk surfaces.

Detailed Description

Implementation of the IGeometryRealmConvTool.

At initialization stage the tool associates every Acts::Surface with an ATLAS identifier to convert the sensitive surfaces without extra memory allocation. If portals and free surfaces are converted as new free Trk::Surfaces with bounds. To return aligned muon surfaces in the Acts -> Trk conversion, the tool has a data dependency on the legacy Muon::DetectorManager

Definition at line 27 of file GeometryRealmConvTool.h.

Constructor & Destructor Documentation

~GeometryRealmConvTool()

ActsTrk::GeometryRealmConvTool::~GeometryRealmConvTool ( )

default

Member Function Documentation

convertSurfaceToActs()

std::shared_ptr< const Acts::Surface > ActsTrk::GeometryRealmConvTool::convertSurfaceToActs ( const Trk::Surface & atlasSurface ) const

finaloverridevirtual

Translate the parsed Trk surface into an Acts surface.

The detector element identifier of the surface needs to be filled into the internal tool's look-up map. Otherwise an exception is thrown.

Parameters

atlasSurface

Refrence to the Trk surface to translate

Definition at line 195 of file GeometryRealmConvTool.cxx.

                                                                                                                     {
        Identifier atlasID = atlasSurface.associatedDetectorElementIdentifier();
        auto it = m_actsSurfaceMap.find(atlasID);
        if (it != m_actsSurfaceMap.end()) {
          return it->second;
        }
        const Amg::Transform3D& trf{atlasSurface.transform()};
        switch (atlasSurface.type()){
            using enum Trk::SurfaceType;
            case Plane:
                return Acts::Surface::makeShared<Acts::PlaneSurface>(trf);
            case Perigee:
                return Acts::Surface::makeShared<Acts::PerigeeSurface>(trf);
            case Line:
                return Acts::Surface::makeShared<Acts::StrawSurface>(trf);
            // TODO - implement the missing types?
            default: {
              break;
            }
        }
        std::stringstream surfStr{};
        atlasSurface.dump(surfStr);  
        throw std::domain_error(std::format("Failed to translate surface {:}", surfStr.str()));
    }

convertSurfaceToTrk()

SurfacePtr_t ActsTrk::GeometryRealmConvTool::convertSurfaceToTrk ( const EventContext & ctx, const Acts::Surface & actsSurface ) const

finaloverridevirtual

Translates the parsed Acts surface into a Trk::Surface via associated detector element.

For the ID measurements a direct link is provided and for the muon measurements the look-up is performed via the associated Identifier and the detector manager. Other surfaces trigger the creation of new free Trk surfaces

Parameters

ctx	The current event context
actsSurface	Refrence to the acts surface to translate

Produce a new free surface

Definition at line 161 of file GeometryRealmConvTool.cxx.

                                                                                                     {
        const auto *detEleBase= dynamic_cast<const IDetectorElementBase*>(actsSurface.surfacePlacement());
        if (!detEleBase) {
           return translateFreeSurface(ctx, actsSurface);
        }
        switch (detEleBase->detectorType()) {
            using enum DetectorType;
            case Pixel:
            case Sct:
            case Hgtd:
            case Trt: {
                const auto actsElement = dynamic_cast<const ActsDetectorElement*>(detEleBase);
                if (actsElement) {
                    return SurfacePtr_t{&actsElement->atlasSurface()};
                }
                break;
            } case Mdt:
            case Rpc:
            case Tgc:
            case Csc:
            case sTgc:
            case Mm: {
                const MuonGM::MuonDetectorManager* detMgr{nullptr};
                if (!SG::get(detMgr, m_muonMgrKey, ctx).isSuccess() || !detMgr) {
                    THROW_EXCEPTION("Failed to retrieve the muon detector manager");
                }
                return SurfacePtr_t{&detMgr->getReadoutElement(detEleBase->identify())->surface(detEleBase->identify())};
            } default:
                break;
        }
        return translateFreeSurface(ctx, actsSurface);
    }

convertTrackParametersToActs()

Acts::BoundTrackParameters ActsTrk::GeometryRealmConvTool::convertTrackParametersToActs ( const EventContext & ctx, const Trk::TrackParameters & atlasParameter, Trk::ParticleHypothesis hypothesis = Trk::pion ) const

finaloverridevirtual

Translates the Trk track parameters into bound Acts track parameters with a particle hypothesis.

Parameters

atlasParameter	The Trk parameters to translate.
gcts	Geometry context needed for special treatment of the annulus bounds
hypothesis	Track hypothesis to use

Definition at line 221 of file GeometryRealmConvTool.cxx.

                                                                                                               {
 
        std::shared_ptr<const Acts::Surface> actsSurface{};
        Acts::BoundVector params{};
        const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
 
        // get the associated surface
        try {
            actsSurface = convertSurfaceToActs(atlasParameter.associatedSurface());
        } catch (const std::exception &e) {
            ATH_MSG_ERROR("Could not find ACTS detector surface for this TrackParameter:");
            ATH_MSG_ERROR(atlasParameter);
            throw;  // Nothing we can do, so just pass exception on...
        }
 
        // Construct track parameters
        const auto& atlasParam{atlasParameter.parameters()};
        if (actsSurface->bounds().type() == Acts::SurfaceBounds::BoundsType::eAnnulus) {
            // Annulus surfaces are constructed differently in Acts/Trk so we need to
            // convert local coordinates
            const Amg::Vector3D& position{atlasParameter.position()};
            auto result = actsSurface->globalToLocal(tgContext, position, atlasParameter.momentum());
            if (result.ok()) {
            params << (*result)[0], (*result)[1], atlasParam[Trk::phi0],
                atlasParam[Trk::theta],
                atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV),
                0.;
            } else {
            ATH_MSG_WARNING("Unable to convert annulus surface - globalToLocal failed");
            }
        } else {
            params << atlasParam[Trk::locX], atlasParam[Trk::locY],
                     atlasParam[Trk::phi0], atlasParam[Trk::theta],
                     atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV), 0.;
        }
 
        std::optional<Acts::BoundMatrix> cov{};
        if (atlasParameter.covariance()) {
            cov = Acts::BoundMatrix::Identity();
            cov->topLeftCorner(5, 5) = *atlasParameter.covariance();
 
            // Convert the covariance matrix from MeV
            // FIXME: This needs to handle the annulus case as well - currently the cov
            // is wrong for annulus surfaces
            for (int i = 0; i < cov->rows(); ++i) {
                (*cov)(i, 4) = (*cov)(i, 4) / 1_MeV;
            }
            for (int i = 0; i < cov->cols(); ++i) {
                (*cov)(4, i) = (*cov)(4, i) / 1_MeV;
            }
        }
        return Acts::BoundTrackParameters{actsSurface, params, std::move(cov), 
                                          ParticleHypothesis::convert(hypothesis)};
    }

convertTrackParametersToTrk()

std::unique_ptr< Trk::TrackParameters > ActsTrk::GeometryRealmConvTool::convertTrackParametersToTrk ( const EventContext & ctx, const Acts::BoundTrackParameters & actsParameters ) const

finaloverridevirtual

Translates the bounded Acts track parameters to Trk parameters.

The bound parameter surface must be translatble by the tool

Parameters

ctx	EventContext
actsParameter	Refrence to the bounded parameters to translate

Convert to free parameters

Back conversion to bound parameters of the helper plane

Definition at line 278 of file GeometryRealmConvTool.cxx.

                                                                                                                       {
                                                                  
                                                                  
        std::optional<AmgSymMatrix(5)> cov = std::nullopt;
        if (actsParameter.covariance()) {
            AmgSymMatrix(5) newcov(actsParameter.covariance()->topLeftCorner<5, 5>());
            // Convert the covariance matrix to GeV
            for (int i = 0; i < newcov.rows(); i++) {
            newcov(i, 4) = newcov(i, 4) * 1_MeV;
            }
            for (int i = 0; i < newcov.cols(); i++) {
            newcov(4, i) = newcov(4, i) * 1_MeV;
            }
            cov = newcov;
        }
 
        const Acts::Surface &actsSurface = actsParameter.referenceSurface();
        SurfacePtr_t trkSurface = convertSurfaceToTrk(ctx, actsSurface);
        switch (actsSurface.type()) {
            case Acts::Surface::SurfaceType::Cone: {
                const auto &coneSurface = static_cast<const Trk::ConeSurface&>(*trkSurface);
                return std::make_unique<Trk::AtaCone>(
                    actsParameter.get<Acts::eBoundLoc0>(),
                    actsParameter.get<Acts::eBoundLoc1>(),
                    actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, coneSurface, cov);
            } case Acts::Surface::SurfaceType::Cylinder: {
                const auto &cylSurface{static_cast<const Trk::CylinderSurface&>(*trkSurface)};
                return std::make_unique<Trk::AtaCylinder>(
                    actsParameter.get<Acts::eBoundLoc0>(),
                    actsParameter.get<Acts::eBoundLoc1>(),
                    actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cylSurface, cov);
            } case Acts::Surface::SurfaceType::Disc: {
                if (trkSurface->type() == Trk::SurfaceType::Disc) {
                    const auto& discSurface{static_cast<const Trk::DiscSurface&>(*trkSurface)};
                    return std::make_unique<Trk::AtaDisc>(
                        actsParameter.get<Acts::eBoundLoc0>(),
                        actsParameter.get<Acts::eBoundLoc1>(),
                        actsParameter.get<Acts::eBoundPhi>(),
                        actsParameter.get<Acts::eBoundTheta>(),
                        actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, discSurface, cov);
                } else if (trkSurface->type() == Trk::SurfaceType::Plane) {
                    const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
                    auto& planeSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
                    // need to convert to plane position on plane surface (annulus bounds)
                    auto helperSurface = Acts::Surface::makeShared<Acts::PlaneSurface>(planeSurface.transform());
 
                    auto covpc = actsParameter.covariance().value();
                    Acts::FreeVector freePars = Acts::transformBoundToFreeParameters(actsSurface, tgContext, 
                                                                                     actsParameter.parameters());

                    Acts::BoundVector targetPars = Acts::transformFreeToBoundParameters(freePars,
                                                            *helperSurface, tgContext).value();
 
                                                            
                    Acts::FreeMatrix freeTransportJacobian{Acts::FreeMatrix::Identity()};
 
                    Acts::FreeVector freeToPathDerivatives{Acts::FreeVector::Zero()};
                    freeToPathDerivatives.head<3>() = freePars.segment<3>(Acts::eFreeDir0);
 
                    auto boundToFreeJacobian = actsSurface.boundToFreeJacobian(tgContext, 
                                                                               freePars.segment<3>(Acts::eFreePos0),
                                                                               freePars.segment<3>(Acts::eFreeDir0));
 
                    Acts::BoundMatrix boundToBoundJac = 
                            Acts::detail::boundToBoundTransportJacobian(tgContext, freePars, 
                                                                         boundToFreeJacobian, freeTransportJacobian, 
                                                                         freeToPathDerivatives, *helperSurface);
 
                    Acts::BoundMatrix targetCov{boundToBoundJac * covpc * boundToBoundJac.transpose()};
 
                    return std::make_unique<Trk::AtaPlane>(
                        targetPars[Acts::eBoundLoc0], targetPars[Acts::eBoundLoc1],
                        targetPars[Acts::eBoundPhi], targetPars[Acts::eBoundTheta],
                        targetPars[Acts::eBoundQOverP] * 1_MeV, planeSurface,
                        targetCov.topLeftCorner<5, 5>());
                } else {
                    throw std::domain_error("Acts::DiscSurface is not associated with ATLAS disc or plane surface");
                }
                break;
            } case Acts::Surface::SurfaceType::Perigee: {
                const auto& perSurface = static_cast<const Trk::PerigeeSurface&>(*trkSurface);
                return std::make_unique<Trk::Perigee>(
                    actsParameter.get<Acts::eBoundLoc0>(),
                    actsParameter.get<Acts::eBoundLoc1>(),
                    actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, perSurface, cov);
            } case Acts::Surface::SurfaceType::Plane: {
                auto &plaSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
                return std::make_unique<Trk::AtaPlane>(
                    actsParameter.get<Acts::eBoundLoc0>(),
                    actsParameter.get<Acts::eBoundLoc1>(),
                    actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, plaSurface, cov);
            } case Acts::Surface::SurfaceType::Straw: {
                auto& lineSurface{static_cast<const Trk::StraightLineSurface&>(*trkSurface)};
                return std::make_unique<Trk::AtaStraightLine>(
                    actsParameter.get<Acts::eBoundLoc0>(),
                    actsParameter.get<Acts::eBoundLoc1>(),
                    actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, lineSurface, cov);
            } case Acts::Surface::SurfaceType::Curvilinear: {
                const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
                return std::make_unique<Trk::CurvilinearParameters>(
                    actsParameter.position(tgContext), actsParameter.get<Acts::eBoundPhi>(),
                    actsParameter.get<Acts::eBoundTheta>(),
                    actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cov);
            } case Acts::Surface::SurfaceType::Other: {
                break;
            }
        }
        throw std::domain_error("Surface type not found");
    }

initialize()

StatusCode ActsTrk::GeometryRealmConvTool::initialize ( )

finaloverridevirtual

Definition at line 54 of file GeometryRealmConvTool.cxx.

                                                 {
        if (parent() != toolSvc()) {
              ATH_MSG_ERROR("The tool is initialized as a private tool but should be public");
              return StatusCode::FAILURE;
        }
        ATH_CHECK(m_trackingGeometryTool.retrieve());
        m_trackingGeometryTool->trackingGeometry()->visitSurfaces([&](const Acts::Surface *surface) {
             // find acts surface with the same detector element ID
             if (!surface->isSensitive()) {
                return;
            }
            const auto *actsElement = dynamic_cast<const IDetectorElementBase*>(surface->surfacePlacement());
            if (!actsElement) {
               return;
            }
            // Conversion from Acts to ATLAS surface impossible for the TRT so the TRT
            // surfaces are not stored in this map
            if (actsElement->detectorType() == DetectorType::Trt) {
                return;
            }
            auto [it, ok] = m_actsSurfaceMap.insert(std::make_pair(actsElement->identify(), surface->getSharedPtr()));
            if (!ok) {
                ATH_MSG_WARNING("ATLAS ID " << actsElement->identify()
                                            << " has two ACTS surfaces: "
                                            << it->second->geometryId() << " and "
                                            << surface->geometryId());
            }
        });
        ATH_CHECK(m_muonMgrKey.initialize(m_extractMuonSurfaces));
        return StatusCode::SUCCESS;
    } 

translateBounds()

std::shared_ptr< Trk::SurfaceBounds > ActsTrk::GeometryRealmConvTool::translateBounds ( const Acts::SurfaceBounds & bounds ) const

private

Translate the Acts surface bounds to its equivalent in the Trk realm.

Note

Not all bounds are implemented

Parameters

bounds

Refrence to the bounds to be translated

Definition at line 86 of file GeometryRealmConvTool.cxx.

                                                                                    {
        switch (bounds.type()) {
            using enum Acts::SurfaceBounds::BoundsType;
            case eRectangle:{
              using ParEnum_t = Acts::RectangleBounds::BoundValues;
              const auto& cBounds = static_cast<const Acts::RectangleBounds&>(bounds);
              return std::make_shared<Trk::RectangleBounds>(cBounds.get(ParEnum_t::eMaxX), 
                                                            cBounds.get(ParEnum_t::eMaxY));
            } case eTrapezoid: {
                using ParEnum_t = Acts::TrapezoidBounds::BoundValues;
                const auto& cBounds = static_cast<const Acts::TrapezoidBounds&>(bounds);
                return std::make_shared<Trk::TrapezoidBounds>(cBounds.get(ParEnum_t::eHalfLengthXnegY),
                                                              cBounds.get(ParEnum_t::eHalfLengthXposY),
                                                              cBounds.get(ParEnum_t::eHalfLengthY));
          } case eDisc: {
            using ParEnum_t = Acts::RadialBounds::BoundValues;
            const auto& cBounds = static_cast<const Acts::RadialBounds&>(bounds);
            return std::make_shared<Trk::DiscBounds>(cBounds.get(ParEnum_t::eMinR),
                                                     cBounds.get(ParEnum_t::eMaxR),
                                                     cBounds.get(ParEnum_t::eAveragePhi),
                                                     cBounds.get(ParEnum_t::eHalfPhiSector));
        } case eCylinder: {
            using ParEnum_t = Acts::CylinderBounds::BoundValues;
            const auto& cBounds = static_cast<const Acts::CylinderBounds&>(bounds);
            return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                         cBounds.get(ParEnum_t::eHalfPhiSector),
                                                         cBounds.get(ParEnum_t::eAveragePhi),
                                                         cBounds.get(ParEnum_t::eHalfLengthZ));
        } case eLine: {
            using ParEnum_t = Acts::LineBounds::BoundValues;
            const auto& cBounds = static_cast<const Acts::LineBounds&>(bounds);
            return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                         cBounds.get(ParEnum_t::eHalfLengthZ));
        } case eDiamond: {
            using ParEnum_t = Acts::DiamondBounds::BoundValues;
            const auto& cBounds = static_cast<const Acts::DiamondBounds&>(bounds);
            return std::make_shared<Trk::DiamondBounds>(cBounds.get(ParEnum_t::eHalfLengthXnegY),
                                                        cBounds.get(ParEnum_t::eHalfLengthXzeroY),
                                                        cBounds.get(ParEnum_t::eHalfLengthXposY),
                                                        cBounds.get(ParEnum_t::eHalfLengthYneg),
                                                        cBounds.get(ParEnum_t::eHalfLengthYpos));
        } default:
            break;
        }
        THROW_EXCEPTION("The bounds "<<bounds<<" cannot be translated");
        return nullptr;
    }

translateFreeSurface()

SurfacePtr_t ActsTrk::GeometryRealmConvTool::translateFreeSurface ( const EventContext & ctx, const Acts::Surface & surface ) const

private

Translate a surface that is not associated with any detector element.

Bounds of the surface are also translated

Parameters

ctx	The event context to access the aligned detector
surface	Reference to the Acts surface for translation

Definition at line 133 of file GeometryRealmConvTool.cxx.

                                                                                               {
        const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
        const Amg::Transform3D& trf{surface.localToGlobalTransform(tgContext)};
        switch (surface.type()) {
            using enum Acts::Surface::SurfaceType;
            case Plane:
              return SurfacePtr_t{new Trk::PlaneSurface(trf, translateBounds(surface.bounds()))};
            case Cylinder:
                return SurfacePtr_t{new Trk::CylinderSurface(trf,
                       std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds())))};
            case Perigee:
                return SurfacePtr_t{new Trk::PerigeeSurface(trf)};
            case Disc:
                return SurfacePtr_t{new Trk::DiscSurface(trf,
                       std::dynamic_pointer_cast<Trk::DiscBounds>(translateBounds(surface.bounds())))};
            case Straw: {
                auto bounds = std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds()));
                return SurfacePtr_t{new Trk::StraightLineSurface(trf, bounds->r(), bounds->halflengthZ())};
            } default:
              break;
        }
        THROW_EXCEPTION("ActsToTrkConverterTool() - Surface cannot be translated " 
                        <<surface.toString(tgContext));
 
        return nullptr;
    }

Member Data Documentation

m_actsSurfaceMap

std::unordered_map<Identifier, std::shared_ptr<const Acts::Surface> > ActsTrk::GeometryRealmConvTool::m_actsSurfaceMap {}

private

Definition at line 63 of file GeometryRealmConvTool.h.

{};

m_extractMuonSurfaces

Gaudi::Property<bool> ActsTrk::GeometryRealmConvTool::m_extractMuonSurfaces

private

Initial value:

{this, "ExtractMuonSurfaces", false,
                                                        "If True, use the MuonDetectorManager to extract the Muon surfaces"}

Definition at line 65 of file GeometryRealmConvTool.h.

                                                     {this, "ExtractMuonSurfaces", false,
                                                        "If True, use the MuonDetectorManager to extract the Muon surfaces"};

m_muonMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> ActsTrk::GeometryRealmConvTool::m_muonMgrKey {this, "MuonManagerKey", "MuonDetectorManager"}

private

Detector manager to fetch the legacy Trk surfaces.

Definition at line 69 of file GeometryRealmConvTool.h.

{this, "MuonManagerKey", "MuonDetectorManager"};

m_trackingGeometry

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

private

Definition at line 62 of file GeometryRealmConvTool.h.

{};

m_trackingGeometryTool

PublicToolHandle<ITrackingGeometryTool> ActsTrk::GeometryRealmConvTool::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}

private

Definition at line 60 of file GeometryRealmConvTool.h.

{this, "TrackingGeometryTool", ""};

---

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

• GeometryRealmConvTool.h
• GeometryRealmConvTool.cxx