MuonR4::xAODSegmentCnvAlg Class Reference

The xAODSegmentCnvAlg takes MuonR4::Segments and converts them into a single xAOD::MuonSegmentContainer. More...

#include <xAODSegmentCnvAlg.h>

Inheritance diagram for MuonR4::xAODSegmentCnvAlg:

Classes
struct	PrepDataCollectorShip
	Auxiliary struct to ship the WriteDecorHandle and writeHandles needed to link the uncalibrated meausrements to the segment. More...
struct	Counter
	Helper struct to keep track of the number of precision, trigger phi and trigger eta hits. More...

Public Member Functions
virtual StatusCode	initialize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
using	PrdCont_t = xAOD::UncalibratedMeasurementContainer
	Abrivation to call an uncalibrated measurement container.
using	PrdLink_t = ElementLink<PrdCont_t>
	Abrivation to call the link to an element inside an uncalibrated measurement container.
using	PrdLinkVec_t = std::vector<PrdLink_t>
	Abrivation of a collection of Prd links.
using	DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>
	Abrivation of the extra declared auxVariables.
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	linkMeasurements (const ActsTrk::GeometryContext &gctx, const Segment &inSegment, xAOD::MuonSegment &targetSegment, PrepDataCollectorShip &ship) const
	Decorate the prd links onto the output muon segment.
void	evaluateSummary (const EventContext &ctx, xAOD::MuonSegment &segment) const
	Calculate the number of hits, outliers and holes on the segment and set the hit summary fields of the passed segment.
void	findHoles (const EventContext &ctx, const Acts::BoundTrackParameters &startPars, const Acts::Surface *target, const std::unordered_set< Identifier > &geoIdsWithHits, Counter &holeCounter) const
	Find potential sensitive surfaces crossed by the segment but without contributing measurements.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
	IdHelperSvc for Identifier printing & manipulation.
SG::ReadHandleKeyArray< SegmentContainer >	m_readKeys {this, "InSegmentKeys", {"R4MuonSegments"}}
	Input segment container key.
SG::WriteHandleKey< xAOD::MuonSegmentContainer >	m_writeKey {this, "OutSegmentKey", "MuonSegmentsFromR4"}
	Output segment container key.
ActsTrk::GeoContextReadKey_t	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Alignment container key.
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
	Tracking geometry tool to search for holes.
ToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", ""}
	Acts extrapolation tool to search for holes.
DecorKey_t	m_prdLinkKey {this, "PrdLinkKey", m_writeKey, "prdLinks" }
	Decoration to the links to the associated Uncalibrated measurements.
DecorKey_t	m_prdStateKey {this, "PrdStateKey", m_writeKey, "prdState"}
	Decoration to the PrdLink state (I.e.
DecorKey_t	m_localSegParKey {this, "LocalSegParKey", m_writeKey, "localSegPars"}
	Decoration of the local segment parameters.
DecorKey_t	m_localSegCovKey {this, "LocalCovParKey", m_writeKey, "localSegCov"}
	Decoration of the local fit covariance parameters.
DecorKey_t	m_parentSegKey {this, "ParentSegmentKey", m_writeKey, "parentSegment"}
	Decoration of the original segment.
SG::WriteHandleKey< xAOD::CombinedMuonStripContainer >	m_combMeasKey {this, "combinedPrdKey", "CombinedMuonPrds"}
	Auxiliary container to model two measurements in the same gas gap as a single track state.
ActsTrk::AuxiliaryMeasurementHandler	m_auxMeasProv {this}
	Handler to parse the auxiliary beam spot constaint.
ActsTrk::ContextUtility	m_ctxProvider {this}
	Context provider for geometry, magnetic field and calibration contexts.
Gaudi::Property< bool >	m_convertBeamSpot {this, "convertBeamSpot", false}
	Flag to convert the beamspot constaint as well.
Gaudi::Property< bool >	m_estimateHoles {this, "estimateHoles", true}
	Flag to tell whether the hole summary shall be written.
Gaudi::Property< double >	m_extraHolePath {this, "extraHolePath", 20.*Gaudi::Units::cm}
	Extra path length for the propagation after the last surface was crossed.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

The xAODSegmentCnvAlg takes MuonR4::Segments and converts them into a single xAOD::MuonSegmentContainer.

The segments carry the global segment position and direction, the fit quality in terms of chi2 & nDoF, and the hit, outlier and hole hit count summary. For the latter, the algortihm optionally launches a hole search using the Acts::TrackingGeometry. Further, the local parameters and covariance from the fit are decorated onto the segment. Finally, the ElementLinks to the contributing measurements are attached. Prds from the uncombined space points (mainly Mdt, Mm, BI-RPC, sTGC pad) are directly appended to the list. The eta & phi measurements of Rpc/Tgc/sTgc which are within the same gasgap are combined in a CombindMuonStrip object which itself is then appended to the list. Optionally, the conversion alg can also convert the beamspot measurement into a xAOD::UncalibratedMeasurement. For each measurement, the flag whether it was an outlier or not is also stored.

Definition at line 45 of file xAODSegmentCnvAlg.h.

Member Typedef Documentation

DecorKey_t

using MuonR4::xAODSegmentCnvAlg::DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>

private

Abrivation of the extra declared auxVariables.

Definition at line 152 of file xAODSegmentCnvAlg.h.

PrdCont_t

using MuonR4::xAODSegmentCnvAlg::PrdCont_t = xAOD::UncalibratedMeasurementContainer

private

Abrivation to call an uncalibrated measurement container.

Definition at line 54 of file xAODSegmentCnvAlg.h.

PrdLink_t

using MuonR4::xAODSegmentCnvAlg::PrdLink_t = ElementLink<PrdCont_t>

private

Abrivation to call the link to an element inside an uncalibrated measurement container.

Definition at line 57 of file xAODSegmentCnvAlg.h.

PrdLinkVec_t

using MuonR4::xAODSegmentCnvAlg::PrdLinkVec_t = std::vector<PrdLink_t>

private

Abrivation of a collection of Prd links.

Definition at line 59 of file xAODSegmentCnvAlg.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evaluateSummary()

void MuonR4::xAODSegmentCnvAlg::evaluateSummary ( const EventContext & ctx, xAOD::MuonSegment & segment ) const

private

Calculate the number of hits, outliers and holes on the segment and set the hit summary fields of the passed segment.

Parameters

ctx	EventContext to access conditions data and to propagate
segment	The segment for which the hit summary shall be evaluated

Instantiate one counter for hits, outliers, holes

Also write down the geometryIdentifiers of the segment measurements

Calculate the segment start parameters

Definition at line 276 of file xAODSegmentCnvAlg.cxx.

                                                                            {
 

        Counter hits{}, outliers{}, holes{};
        std::unordered_set<Identifier> crossedSurfaces{};
        const std::size_t nMeas = nMeasurements(segment);
 
        const Acts::Surface* startSurface{}, *lastSurface{};
        const Acts::TrackingGeometry* trackingGeo = m_estimateHoles ? m_trackingGeometrySvc->trackingGeometry().get() : nullptr;
 
        ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Loop over "<<nMeas<<" measurements.");
        for (std::size_t m = 0 ; m < nMeas; ++m) {
            const bool isOutlier = isOutlierMeasurement(segment, m);
            Counter& increment = {isOutlier ? outliers: hits};
            const xAOD::UncalibratedMeasurement* meas = getMeasurement(segment, m);
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Evaluate measurement "<<m_idHelperSvc->toString(xAOD::identify(meas))
                    <<", outlier: "<<isOutlier);
            increment.precision  += xAOD::isPrecisionHit(meas);
            const auto* muonMeas = dynamic_cast<const xAOD::MuonMeasurement*>(meas);
            increment.triggerPhi += (!muonMeas|| muonMeas->measuresPhi());
            increment.triggerEta += (!muonMeas|| !muonMeas->measuresPhi()) && !xAOD::isPrecisionHit(meas);
            // Count measurement holes of the trigger hits
            if (!isOutlier && meas->numDimensions() == 1) {
                if (meas->type() == xAOD::UncalibMeasType::RpcStripType) {
                  //coverity[FORWARD_NULL]
                    const auto* re = static_cast<const MuonGMR4::RpcReadoutElement*>(muonMeas->readoutElement());
                    if (!muonMeas->measuresPhi() && re->nPhiStrips()) {
                        ++holes.triggerPhi;
                    } else if (muonMeas->measuresPhi()) {
                        ++holes.triggerEta;
                    }
                } else if (meas->type() == xAOD::UncalibMeasType::TgcStripType) {
                    //coverity[FORWARD_NULL]
                    const auto* re = static_cast<const MuonGMR4::TgcReadoutElement*>(muonMeas->readoutElement());
                        if (!muonMeas->measuresPhi() && re->numStrips(muonMeas->layerHash())) {
                        ++holes.triggerPhi;
                    } else if (muonMeas->measuresPhi() && re->numWireGangs(muonMeas->layerHash())) {
                        ++holes.triggerEta;
                    }
                } else if (meas->type() == xAOD::UncalibMeasType::sTgcStripType)  {
                    if (!xAOD::isPrecisionHit(meas)) {
                        ++holes.precision;
                    } else {
                        ++holes.triggerPhi;
                    }
                }
            }
            
            
            if (!m_estimateHoles) {
                continue;
            }   
            const Acts::Surface& surface = xAOD::muonSurface(meas);
            if (!muonMeas){
                continue;
            }
            crossedSurfaces.insert( muonMeas->type() != xAOD::UncalibMeasType::MdtDriftCircleType ? 
                                    m_idHelperSvc->gasGapId(muonMeas->identify()) :
                                    muonMeas->identify());
            const auto* volume = highestAlignable(trackingGeo->findVolume(volumeId(surface)));
            assert(volume != nullptr);
            if (!startSurface) {
                startSurface = MuonGMR4::bottomBoundary(*volume);
            } else if (m +1 == nMeas) {
                lastSurface = MuonGMR4::topBoundary(*volume);
            }
        }
        if (m_estimateHoles) {
            const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
            auto atSurface = startSurface->intersect(tgContext, segment.position(), segment.direction(),
                                                      Acts::BoundaryTolerance::Infinite()).closest();
        
            auto startPars = Acts::BoundTrackParameters::create(tgContext, startSurface->getSharedPtr(),
                                                                ActsTrk::convertPosToActs(atSurface.position()),
                                                                segment.direction(), 1./ 5._TeV, std::nullopt,
                                                                Acts::ParticleHypothesis::muon());
            if (startPars.ok()) {
                findHoles(ctx, *startPars, lastSurface, crossedSurfaces, holes);
            } else {
                ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Start parameters not defined.");
            }
        }
        segment.setNHits(hits.precision, hits.triggerPhi, hits.triggerEta);
        segment.setNOutliers(outliers.precision, outliers.triggerPhi, outliers.triggerEta);
        segment.setNHoles(holes.precision, holes.triggerPhi, holes.triggerEta);
    }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode MuonR4::xAODSegmentCnvAlg::execute ( const EventContext & ctx ) const

finaloverridevirtual

Counter for the reco segment link

Definition at line 64 of file xAODSegmentCnvAlg.cxx.

                                                                       {
        const ActsTrk::GeometryContext* gctx{nullptr};
        ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
 
        PrepDataCollectorShip measDecorator{*this, ctx, gctx->context()};
 
        xAOD::FillContainer<xAOD::MuonSegmentContainer,
                           xAOD::MuonSegmentAuxContainer> outContainer{};
        
        
        ATH_CHECK(outContainer.record(m_writeKey, ctx));
        ATH_CHECK(measDecorator.prdCombContainer.record(m_combMeasKey, ctx));
        
        SG::WriteDecorHandle<xAOD::MuonSegmentContainer, SegLink_t> dec_parentLink{m_parentSegKey, ctx};
        SG::WriteDecorHandle<xAOD::MuonSegmentContainer, SegPars_t> dec_locPars{m_localSegParKey, ctx};
        SG::WriteDecorHandle<xAOD::MuonSegmentContainer, SegCov_t> dec_locCov{m_localSegCovKey, ctx};
 
        for (const SG::ReadHandleKey<SegmentContainer>& key : m_readKeys) {
            const SegmentContainer* segmentContainer{nullptr};
            ATH_CHECK(SG::get(segmentContainer, key, ctx));
         
            unsigned recoSegIdx{0};
            outContainer->reserve(outContainer->size() + segmentContainer->size());
            for (const Segment* inSegment : *segmentContainer) {
                const MuonGMR4::SpectrometerSector* sector = inSegment->msSector();
 
                xAOD::MuonSegment* convertedSeg = outContainer->push_back(std::make_unique<xAOD::MuonSegment>());
                dec_parentLink(*convertedSeg) = SegLink_t{segmentContainer, recoSegIdx};
                ++recoSegIdx;
            
                const Amg::Vector3D& pos{inSegment->position()};
                const Amg::Vector3D& dir{inSegment->direction()};
                convertedSeg->setPosition(pos.x(), pos.y(), pos.z());
                convertedSeg->setDirection(dir.x(), dir.y(), dir.z());
 
                convertedSeg->setIdentifier(sector->sector(), sector->chamberIndex(),
                                           sector->side(), inSegment->technology());
                convertedSeg->setFitQuality(inSegment->chi2(), inSegment->nDoF());
 
                using enum ParamDefs;
                convertedSeg->setT0Error(inSegment->segementT0(), 
                                         Amg::error(inSegment->covariance(), Acts::toUnderlying(t0)));
 
                SegPars_t& localPars{dec_locPars(*convertedSeg)};
                const Amg::Transform3D globToLoc{sector->globalToLocalTransform(*gctx)};            
                const Amg::Vector3D locPos{globToLoc * pos};
                const Amg::Vector3D locDir{globToLoc.linear() * dir};
 
                localPars[Acts::toUnderlying(x0)] = locPos.x();
                localPars[Acts::toUnderlying(y0)] = locPos.y();
                localPars[Acts::toUnderlying(theta)] = locDir.theta();
                localPars[Acts::toUnderlying(phi)] = locDir.phi();
                localPars[Acts::toUnderlying(t0)] = inSegment->segementT0();
 
                SegCov_t& localCov{dec_locCov(*convertedSeg)};
                constexpr std::size_t n = Acts::toUnderlying(ParamDefs::nPars);
                for (std::size_t p = 1; p < n; ++p) {
                    for (std::size_t p1 = 0 ; p1 <=p;++p1) {
                        localCov[Acts::vecIdxFromSymMat<n>(p,p1)] = inSegment->covariance()(p, p1);
                    }
                }
                ATH_CHECK(linkMeasurements(*gctx, *inSegment, *convertedSeg, measDecorator));
                evaluateSummary(ctx, *convertedSeg);
            }
        }  
        return StatusCode::SUCCESS;
    }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

findHoles()

void MuonR4::xAODSegmentCnvAlg::findHoles ( const EventContext & ctx, const Acts::BoundTrackParameters & startPars, const Acts::Surface * target, const std::unordered_set< Identifier > & geoIdsWithHits, Counter & holeCounter ) const

private

Find potential sensitive surfaces crossed by the segment but without contributing measurements.

The segment line is propagated from the startPars to the target surface + some margin using the Acts::Propagator. The propaator records every surface crossing. The associated SurfacePlacements are then used to determine the ATLAS identifier and then to assign whether there's a hole or not.

Parameters

ctx	EventContext to be passed to the extrapolation tool
startPars	The start parameters from which the propagation starts. The surface is the bottom boundary surface of the volume where's the first segment measurement.
target	The top boundary surface of the volume with the last segment measurement.
geoIdsWithHits	The list of ATLAS identifiers with segmen measurements (outlier + hit)
holeCounter	Mutable reference to the segment hole counter.

Surface is already part of the measurement pool

We expect at least one hit in the same sector to avoid that hits in the sector-overlap from the adjacent chamber are marked as holes. While they are not part of the segment by construction

Definition at line 366 of file xAODSegmentCnvAlg.cxx.

                                                                  {
        
 
        using SurfaceRecordOptions = ActsTrk::IExtrapolationTool::SurfaceRecordOptions;
        SurfaceRecordOptions propOpts{target, m_extraHolePath};
        propOpts.recordMaterial = false;
        propOpts.recordPassive = false;
        propOpts.recordSensitive = true;
 
        
        auto propResult = m_extrapolationTool->propagateAndRecord(ctx, startPars, propOpts);
        if (!propResult.ok()) {
            return;
        }
 
        /* Loop over the track record to filter out the holes*/
        for (Acts::BoundTrackParameters& record : (*propResult)) {
            const auto* placement = dynamic_cast<const ActsTrk::SurfacePlacement*>(record.referenceSurface().surfacePlacement());
            assert(placement != nullptr);
            const auto* detEl = static_cast<const MuonGMR4::MuonReadoutElement*>(placement->detectorElement());
            using enum ActsTrk::DetectorType;
            if (layersWithHits.count(placement->identify())) {
                continue;
            } 
            if(std::ranges::none_of(layersWithHits,[&](const Identifier& recorded){
                return m_idHelperSvc->chamberIndex(recorded) == detEl->chamberIndex() &&
                        m_idHelperSvc->stationPhi(recorded) == detEl->stationPhi();
            })) {
                ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Surface "
                    <<m_idHelperSvc->toStringGasGap(placement->identify())<<" is not in the same sector");
                continue;
            }
            switch (placement->detectorType()) {
                case Mm:
                case Mdt: {
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Precision hole detected "
                                   <<m_idHelperSvc->toString(placement->identify()));
                    ++holeCounter.precision;
                    break;
                } case Rpc: {
                    const auto* re = static_cast<const MuonGMR4::RpcReadoutElement*>(placement->detectorElement());
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Rpc hole detected "
                                <<m_idHelperSvc->toStringGasGap(placement->identify())<<".");
                    ++holeCounter.triggerEta;
                    holeCounter.triggerPhi += (re->nPhiStrips() > 0);
                    break;
                } case Tgc: {
                    const auto* re = static_cast<const MuonGMR4::TgcReadoutElement*>(placement->detectorElement());
                    holeCounter.triggerEta += (re->numWireGangs(placement->hash())>0);
                    holeCounter.triggerPhi += (re->numStrips(placement->hash())>0);
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Tgc hole detected "
                                <<m_idHelperSvc->toStringGasGap(placement->identify())<<".");
                    break;
                } case sTgc: {
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Precision hole detected "
                                   <<m_idHelperSvc->toString(placement->identify()));
                    ++holeCounter.precision;
                    ++holeCounter.triggerPhi;
                    break;
                } default:
                    ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Unknown detector type "
                                    <<placement->detectorType());
                    break;
            }
        }
    }

initialize()

StatusCode MuonR4::xAODSegmentCnvAlg::initialize ( )

finaloverridevirtual

Definition at line 45 of file xAODSegmentCnvAlg.cxx.

                                             {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_readKeys.initialize());
        ATH_CHECK(m_geoCtxKey.initialize());
        ATH_CHECK(m_writeKey.initialize());
        ATH_CHECK(m_prdLinkKey.initialize());
        ATH_CHECK(m_localSegParKey.initialize());
        ATH_CHECK(m_localSegCovKey.initialize());
        ATH_CHECK(m_parentSegKey.initialize());
        ATH_CHECK(m_combMeasKey.initialize());
        ATH_CHECK(m_prdStateKey.initialize());
        ATH_CHECK(m_auxMeasProv.initialize(m_writeKey.key(), m_convertBeamSpot));
        if (m_estimateHoles) {
            ATH_CHECK(m_trackingGeometrySvc.retrieve());
        }
        ATH_CHECK(m_extrapolationTool.retrieve(EnableTool{m_estimateHoles}));
        ATH_CHECK(m_ctxProvider.initialize(m_estimateHoles));
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

linkMeasurements()

StatusCode MuonR4::xAODSegmentCnvAlg::linkMeasurements ( const ActsTrk::GeometryContext & gctx, const Segment & inSegment, xAOD::MuonSegment & targetSegment, PrepDataCollectorShip & ship ) const

private

Decorate the prd links onto the output muon segment.

Eta & phi measurements are absorbed converted into a CombinedMuonStrip which is a source link linke object carrying a link to both prds. In this way, only one track state is generated later in the track fit from the two measurements. Two assumptions are made for the linking

• There's exclusivley one eta & one phi measurement @maximum on the segment
• The measurements are sorted along the segment trajectory.

  Parameters

  gctx	The geometry context to construct the local segment parameters
  inSegment	The segment from which the space points are collected
  targetSegment	The xAOD segment onto which all the links are decorated
  ship	Reference to the auxiliary ship carrying all the write decor handles needed for the linking

Combine the two prds from the space point to a combined muonstrip and link the latter to the segment.

Size of the bounds purely for visualization purposes

It might be that the segment has anoher 1D-measurement in the same gas gap

The first measurement should always be the eta measurement

Definition at line 133 of file xAODSegmentCnvAlg.cxx.

                                                                                      {
        using State = CalibratedSpacePoint::State;
        // Cache all measurements that can be combined to two measurements in a single gas gap
        std::vector< std::tuple<const xAOD::MuonMeasurement*, State, std::size_t>> combineMap{};
        std::vector< std::tuple<const xAOD::UncalibratedMeasurement*, State, std::size_t>> linkMap{};
 
 
        PrdLinkVec_t& links = ship.dec_prdLinks(copySegment);
        std::vector<char>& linkStates = ship.dec_prdStates(copySegment);
        links.reserve(2*inSegment.measurements().size());
        linkStates.reserve(2*inSegment.measurements().size());

        auto combine = [&](const xAOD::MuonMeasurement* m1, 
                          const xAOD::MuonMeasurement* m2) {
            auto cmbMeas = ship.prdCombContainer->push_back(std::make_unique<xAOD::CombinedMuonStrip>());
 
            cmbMeas->setPrimaryStrip(m1);
            cmbMeas->setSecondaryStrip(m2);
            const auto [locPos, locCov] = xAOD::positionAndCovariance(m1, m2);
            cmbMeas->localCovariance<2>() = xAOD::toStorage(locCov);
            cmbMeas->localPosition<2>() = xAOD::toStorage(locPos);
            const Identifier id1{m1->identify()}, id2{m2->identify()};
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Combine "<<m_idHelperSvc->toString(id1) 
                            <<" & "<<m_idHelperSvc->toString(id2));
            if ((m1->type() != xAOD::UncalibMeasType::sTgcStripType || 
                m_idHelperSvc->stgcIdHelper().channelType(id1) == 
                m_idHelperSvc->stgcIdHelper().channelType(id2))&&
                m_idHelperSvc->measuresPhi(id1) == m_idHelperSvc->measuresPhi(id2)) {
                THROW_EXCEPTION("Cannot combine "<<m_idHelperSvc->toString(id1)
                                <<" & "<<m_idHelperSvc->toString(id2));
            }
            return cmbMeas;
        };
        // Loop over the measurements
        for (const auto [segIdx, meas] : Acts::enumerate(inSegment.measurements())) {
            const SpacePoint* sp = meas->spacePoint();
            if (!sp) {
                if (!m_convertBeamSpot) {
                    continue;
                }
                // Up to now, there's no variety on the beamspot across the segments
                if (!ship.beamSpot) {
                    if (!ship.beamSpotMeasCreator.ok()) {
                        ATH_MSG_ERROR("Cannot create a beamspot measurement");
                        return StatusCode::FAILURE;
                    }
 
                    const Amg::Vector3D beamSpot = inSegment.msSector()->localToGlobalTransform(gctx) *
                                                    meas->localPosition();
                    AmgSymMatrix(2) covariance{AmgSymMatrix(2)::Identity()};
                    using CovIdx = SpacePoint::CovIdx;
                    using ProjectorType = xAOD::AuxiliaryMeasurement::ProjectorType;
                    covariance(0,0) = meas->covariance()[Acts::toUnderlying(CovIdx::etaCov)];
                    covariance(1,1) = meas->covariance()[Acts::toUnderlying(CovIdx::phiCov)];
                    auto surf = Acts::Surface::makeShared<Acts::StrawSurface>(Amg::getTranslate3D(beamSpot),
                                                std::make_shared<Acts::LineBounds>(std::sqrt(covariance(0,0)), 20._m));
 
                    ship.beamSpot = ship.beamSpotMeasCreator->newMeasurement<2>(surf, ProjectorType::e2DimNoTime, covariance);
                    ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Created beamspot measurement "<<(*meas)<<", "
                                    <<surf->toString(gctx.context()));
                }
                linkMap.emplace_back(ship.beamSpot, meas->fitState(), segIdx);
                continue;
            }
            switch (sp->type()) {
                using enum xAOD::UncalibMeasType;
                // Mdt &  micromegas are never combined
                case MdtDriftCircleType:
                case MMClusterType: {
                    linkMap.emplace_back(sp->primaryMeasurement(), meas->fitState(), segIdx);                        
                    break;
                } case RpcStripType:
                  case TgcStripType:
                  case sTgcStripType: {
                    if (sp->primaryMeasurement() && sp->secondaryMeasurement()) {
                        if (sp->primaryMeasurement() != sp->secondaryMeasurement()) {
                            linkMap.emplace_back(combine(sp->primaryMeasurement(), 
                                                         sp->secondaryMeasurement()),
                                                         meas->fitState(), segIdx);
                        } else {  // BI - RPC measurements
                            linkMap.emplace_back(sp->primaryMeasurement(), meas->fitState(), segIdx);
                        }
                    } else {
                        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Append for later combination "<<(*meas));
                        combineMap.emplace_back(sp->primaryMeasurement(), meas->fitState(), segIdx);
                    }
                    break;
                } default:
                    break;
            }
        }
    
        // Finally we need to check whether there're measurements left to combine
        for (std::size_t cmbIdx = 0; cmbIdx < combineMap.size(); ++cmbIdx){
            const xAOD::MuonMeasurement* m1{std::get<0>(combineMap[cmbIdx])};
            const State s1{std::get<1>(combineMap[cmbIdx])};
            const std::size_t segIdx1{std::get<2>(combineMap[cmbIdx])};
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Find another measurement to combine with "
                            <<m_idHelperSvc->toString(m1->identify()));
            if (cmbIdx +1 < combineMap.size()) {
                const xAOD::MuonMeasurement* m2{std::get<0>(combineMap[cmbIdx +1])};
                const State s2{std::get<1>(combineMap[cmbIdx+1])};
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Check whether "<<m_idHelperSvc->toString(m2->identify())
                                <<" is a good candidate");
                // Ensure that they point to the same detector element, are within the same
                // layer and have also the same state
                if (m1->type() == m2->type() &&  m1->identifierHash() == m2->identifierHash() && 
                    m1->layerHash() == m2->layerHash() && s1 == s2) {
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - They match");
                    if (m1->measuresPhi()) {
                        linkMap.emplace_back(combine(m2, m1), s2, segIdx1);
                    } else {
                        linkMap.emplace_back(combine(m1, m2), s1, segIdx1);
                    }
                    ++cmbIdx; // skip the next measurement as it's absorbed here
                    continue;
                }
            }
            ATH_MSG_VERBOSE("No match found");
            linkMap.emplace_back(m1, s1, segIdx1);
        }
 
        std::ranges::sort(linkMap, [](const auto& a, const auto& b){
            return std::get<2>(a) < std::get<2>(b);
        });
 
        for (const auto& [prd, state, segIdx]: linkMap) {
            links.emplace_back(*static_cast<const xAOD::UncalibratedMeasurementContainer*>(prd->container()), 
                                prd->index());
            linkStates.emplace_back(Acts::toUnderlying(state));
        }
        return StatusCode::SUCCESS;
    }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_auxMeasProv

ActsTrk::AuxiliaryMeasurementHandler MuonR4::xAODSegmentCnvAlg::m_auxMeasProv {this}

private

Handler to parse the auxiliary beam spot constaint.

Definition at line 166 of file xAODSegmentCnvAlg.h.

{this};

m_combMeasKey

SG::WriteHandleKey<xAOD::CombinedMuonStripContainer> MuonR4::xAODSegmentCnvAlg::m_combMeasKey {this, "combinedPrdKey", "CombinedMuonPrds"}

private

Auxiliary container to model two measurements in the same gas gap as a single track state.

Definition at line 164 of file xAODSegmentCnvAlg.h.

{this, "combinedPrdKey", "CombinedMuonPrds"};

m_convertBeamSpot

Gaudi::Property<bool> MuonR4::xAODSegmentCnvAlg::m_convertBeamSpot {this, "convertBeamSpot", false}

private

Flag to convert the beamspot constaint as well.

Definition at line 170 of file xAODSegmentCnvAlg.h.

{this, "convertBeamSpot", false};

m_ctxProvider

ActsTrk::ContextUtility MuonR4::xAODSegmentCnvAlg::m_ctxProvider {this}

private

Context provider for geometry, magnetic field and calibration contexts.

Definition at line 168 of file xAODSegmentCnvAlg.h.

{this};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_estimateHoles

Gaudi::Property<bool> MuonR4::xAODSegmentCnvAlg::m_estimateHoles {this, "estimateHoles", true}

private

Flag to tell whether the hole summary shall be written.

Definition at line 172 of file xAODSegmentCnvAlg.h.

{this, "estimateHoles", true};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_extraHolePath

Gaudi::Property<double> MuonR4::xAODSegmentCnvAlg::m_extraHolePath {this, "extraHolePath", 20.*Gaudi::Units::cm}

private

Extra path length for the propagation after the last surface was crossed.

Definition at line 174 of file xAODSegmentCnvAlg.h.

{this, "extraHolePath", 20.*Gaudi::Units::cm};

m_extrapolationTool

ToolHandle<ActsTrk::IExtrapolationTool> MuonR4::xAODSegmentCnvAlg::m_extrapolationTool {this, "ExtrapolationTool", ""}

private

Acts extrapolation tool to search for holes.

Definition at line 149 of file xAODSegmentCnvAlg.h.

{this, "ExtrapolationTool", ""};

m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonR4::xAODSegmentCnvAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Alignment container key.

Definition at line 145 of file xAODSegmentCnvAlg.h.

{this, "AlignmentKey", "ActsAlignment", "cond handle key"};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::xAODSegmentCnvAlg::m_idHelperSvc

private

Initial value:

{this, "MuonIdHelperSvc",  
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

IdHelperSvc for Identifier printing & manipulation.

Definition at line 138 of file xAODSegmentCnvAlg.h.

                                                             {this, "MuonIdHelperSvc",  
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_localSegCovKey

DecorKey_t MuonR4::xAODSegmentCnvAlg::m_localSegCovKey {this, "LocalCovParKey", m_writeKey, "localSegCov"}

private

Decoration of the local fit covariance parameters.

Definition at line 160 of file xAODSegmentCnvAlg.h.

{this, "LocalCovParKey", m_writeKey, "localSegCov"};

m_localSegParKey

DecorKey_t MuonR4::xAODSegmentCnvAlg::m_localSegParKey {this, "LocalSegParKey", m_writeKey, "localSegPars"}

private

Decoration of the local segment parameters.

Definition at line 158 of file xAODSegmentCnvAlg.h.

{this, "LocalSegParKey", m_writeKey, "localSegPars"};

m_parentSegKey

DecorKey_t MuonR4::xAODSegmentCnvAlg::m_parentSegKey {this, "ParentSegmentKey", m_writeKey, "parentSegment"}

private

Decoration of the original segment.

Definition at line 162 of file xAODSegmentCnvAlg.h.

{this, "ParentSegmentKey", m_writeKey, "parentSegment"};

m_prdLinkKey

DecorKey_t MuonR4::xAODSegmentCnvAlg::m_prdLinkKey {this, "PrdLinkKey", m_writeKey, "prdLinks" }

private

Decoration to the links to the associated Uncalibrated measurements.

Definition at line 154 of file xAODSegmentCnvAlg.h.

{this, "PrdLinkKey",  m_writeKey, "prdLinks" };

m_prdStateKey

DecorKey_t MuonR4::xAODSegmentCnvAlg::m_prdStateKey {this, "PrdStateKey", m_writeKey, "prdState"}

private

Decoration to the PrdLink state (I.e.

outlier or valid)

Definition at line 156 of file xAODSegmentCnvAlg.h.

{this, "PrdStateKey", m_writeKey, "prdState"};

m_readKeys

SG::ReadHandleKeyArray<SegmentContainer> MuonR4::xAODSegmentCnvAlg::m_readKeys {this, "InSegmentKeys", {"R4MuonSegments"}}

private

Input segment container key.

Definition at line 141 of file xAODSegmentCnvAlg.h.

{this, "InSegmentKeys", {"R4MuonSegments"}};

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> MuonR4::xAODSegmentCnvAlg::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Tracking geometry tool to search for holes.

Definition at line 147 of file xAODSegmentCnvAlg.h.

{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeKey

SG::WriteHandleKey<xAOD::MuonSegmentContainer> MuonR4::xAODSegmentCnvAlg::m_writeKey {this, "OutSegmentKey", "MuonSegmentsFromR4"}

private

Output segment container key.

Definition at line 143 of file xAODSegmentCnvAlg.h.

{this, "OutSegmentKey", "MuonSegmentsFromR4"};

---

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

• xAODSegmentCnvAlg.h
• xAODSegmentCnvAlg.cxx