#include <MsTrackFindingAlg.h>

Inheritance diagram for MuonR4::MsTrackFindingAlg:

Collaboration diagram for MuonR4::MsTrackFindingAlg:

Public Types
using	OptBoundPars_t = Acts::Result<Acts::BoundTrackParameters>
using	MeasVec_t = std::vector<const xAOD::UncalibratedMeasurement*>

Public Member Functions
virtual	~MsTrackFindingAlg ()
virtual StatusCode	initialize () override final
	Standard algorithm hook to setup the extrapolator, retrieve the tools and declare algorithm's data dependencies.
virtual StatusCode	execute (const EventContext &ctx) const override final
	Standard algorithm execution hook.
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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	fitSeedCandidate (const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const MsTrackSeed &seed, ActsTrk::MutableTrackContainer &outContainer) const
	Attempts to fit the track seed candidate to a full track and returns whether the fit succeeded.
std::pair< OptBoundPars_t, MeasVec_t >	prepareFit (const Acts::GeometryContext &tgContext, const Acts::CalibrationContext &calContext, const MsTrackSeed &seed) const
	Prepares the input to the fit by collecting the measurements on the segment &.
bool	expressAtCaloExit (const EventContext &ctx, ActsTrk::MutableTrackContainer::TrackProxy track) const
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 {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	IdHelperSvc to decode the Identifiers.
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	Pointer to the MuonDetectorManager.
SG::WriteHandleKey< MsTrackSeedContainer >	m_msTrkSeedKey {this, "MsTrkSeedKey", "MsTrackSeeds"}
	Temporary container write handle to push the seeds to store gate for later efficiency analysis.
ToolHandle< ITrackSeedingTool >	m_seedingTool {this, "SeedingTool", ""}
	The track seeding tool to construct the seed candidates and to estimate the initial parameters.
ToolHandle< ActsTrk::IFitterTool >	m_trackFitTool {this, "FittingTool", ""}
	Track fitting tool.
ToolHandle< ISpacePointCalibrator >	m_calibTool {this, "Calibrator", ""}
	Calibration tool to fill the track states.
ToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool" ,"" }
	Track extrapolation tool.
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
	Service handle to the tracking geometry service.
Gaudi::Property< bool >	m_expressAtMsEntrance {this, "expressAtMsEntrance", true}
	Propagate the track at the MS entry and express its parameters.
Gaudi::Property< bool >	m_ignoreFailedMsEntrance {this, "ignoreFailedExtpMsEntrance", true}
	Ignore failed track extrapolations to the entrance.
ActsTrk::ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
ToolHandle< MuonValR4::ITrackVisualizationTool >	m_visualizationTool {this, "VisualizationTool", ""}
	Visualization tool to debug the track finding.
ToolHandle< MuonR4::ITrackSummaryTool >	m_summaryTool {this, "SummaryTool" , ""}
	Handle to the muon summary tool.
SG::WriteHandleKey< ActsTrk::TrackContainer >	m_writeKey {this, "TrackWriteKey", "MsTracks"}
	Key to the output track container.
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

Definition at line 39 of file MsTrackFindingAlg.h.

Member Typedef Documentation

◆ MeasVec_t

using MuonR4::MsTrackFindingAlg::MeasVec_t = std::vector<const xAOD::UncalibratedMeasurement*>

Definition at line 51 of file MsTrackFindingAlg.h.

◆ OptBoundPars_t

using MuonR4::MsTrackFindingAlg::OptBoundPars_t = Acts::Result<Acts::BoundTrackParameters>

Definition at line 50 of file MsTrackFindingAlg.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~MsTrackFindingAlg()

MuonR4::MsTrackFindingAlg::~MsTrackFindingAlg ( )

virtualdefault

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.

95{ return m_detStore; }

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ 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.

85{ return m_evtStore; }

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

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

finaloverridevirtual

Standard algorithm execution hook.

Attach the number of the parent seed to the output container

Definition at line 54 of file MsTrackFindingAlg.cxx.

                                                                       {
        ATH_MSG_VERBOSE("Run track finding in event "<<ctx.eventID().event_number());
        
 
        auto seedContainer = std::make_unique<MsTrackSeedContainer>();
 
        ATH_CHECK(m_seedingTool->findTrackSeeds(ctx, *seedContainer));
 
        if (!m_visualizationTool.empty()) {
            m_visualizationTool->displaySeeds(ctx, *seedContainer);
        }
        const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
        const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
        const Acts::CalibrationContext calContext{m_ctxProvider.getCalibrationContext(ctx)};
        
        
        Acts::VectorTrackContainer trackBackend{};
        Acts::VectorMultiTrajectory trackStateBackend{};
        ActsTrk::MutableTrackContainer cacheTrkContainer{std::move(trackBackend), 
                                                         std::move(trackStateBackend)};
        cacheTrkContainer.addColumn<std::size_t>("parentSeed");
        unsigned seedIdx{0};
        for (const MsTrackSeed& seed : *seedContainer) {
            if (!fitSeedCandidate(tgContext, mfContext, calContext, seed, 
                                  cacheTrkContainer)) {
                ++seedIdx;
                continue;
            }
            auto lastTrack = cacheTrkContainer.getTrack(cacheTrkContainer.size() -1);
            lastTrack.component<std::size_t, Acts::hashString("parentSeed")>() = seedIdx;
            ++seedIdx;
        }
        if (!m_msTrkSeedKey.empty()) {
            SG::WriteHandle writeHandleSeed{m_msTrkSeedKey, ctx};
            ATH_CHECK(writeHandleSeed.record(std::move(seedContainer)));
        }
    
        // Constant declination
        Acts::ConstVectorTrackContainer ctrackBackend{std::move(cacheTrkContainer.container())};
        Acts::ConstVectorMultiTrajectory ctrackStateBackend{std::move(cacheTrkContainer.trackStateContainer())};
        auto ctc = std::make_unique<ActsTrk::TrackContainer>(std::move(ctrackBackend),
                                                             std::move(ctrackStateBackend));
  
        SG::WriteHandle writeHandle{m_writeKey, ctx};
        ATH_CHECK(writeHandle.record(std::move(ctc)));
        return StatusCode::SUCCESS;
    }

◆ expressAtCaloExit()

bool MuonR4::MsTrackFindingAlg::expressAtCaloExit	(	const EventContext &	ctx,
		ActsTrk::MutableTrackContainer::TrackProxy	track ) const

private

Definition at line 211 of file MsTrackFindingAlg.cxx.

                                                                                                  {
        if (!m_expressAtMsEntrance) {
            return true;
        }
        const Acts::BoundTrackParameters startPars = track.createParametersAtReference();
        const Acts::TrackingVolume* msEntrance = m_trackingGeometrySvc->getEnvelope(ActsTrk::SystemEnvelope::CaloExit);
        const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Extrapolate "<<startPars<<", "
            <<startPars.referenceSurface().toString(tgContext)<<" to MS entrance: "<<msEntrance->volumeBounds());
       
        auto parsAtEntrance = m_extrapolationTool->propagate(ctx, startPars, *msEntrance, 
                                                             ActsTrk::IExtrapolationTool::VolumeAbort::atEntrance,
                                                             Acts::Direction::Backward());
        
        if (!parsAtEntrance.ok()) {
            ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Failed to extrapolate "<<startPars<<" to MS entrance");
            return m_ignoreFailedMsEntrance;
        }
        if (parsAtEntrance->referenceSurface().geometryId().withBoundary(0) != msEntrance->geometryId()) {
            ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Parameter extrapolation to "<<(*parsAtEntrance)<<", @"
                            << Amg::toString(parsAtEntrance->referenceSurface().localToGlobalTransform(tgContext))
                            <<" did not end up at "<<msEntrance->geometryId()<<".");
            return m_ignoreFailedMsEntrance;
        }
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Extrapolated start parameters to "<<(*parsAtEntrance)
                      <<", "<<parsAtEntrance->referenceSurface().toString(tgContext));
        track.setReferenceSurface(parsAtEntrance->referenceSurface().getSharedPtr());
        track.parameters() = parsAtEntrance->parameters();
        track.covariance() = (*parsAtEntrance->covariance());
        return true;
    }

◆ 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();
  }

◆ fitSeedCandidate()

bool MuonR4::MsTrackFindingAlg::fitSeedCandidate	(	const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const MsTrackSeed &	seed,
		ActsTrk::MutableTrackContainer &	outContainer ) const

private

Attempts to fit the track seed candidate to a full track and returns whether the fit succeeded.

Parameters

tgContext	Geometry context to access the alignment of the surfaces
mfContextc	Magnetic field context to access the field map during the fit
calContext	Calibration context to access the calibration constants from Store gate during the track state filling
seed	The seed of interest to fit
outContainer	Mutable track container to which the output track is written

Add the links to the segments making up this track as an extra column. Use the indices of the segment objects which can later be transformed into a full ElementLink as there is only one SegmentContainer from which the seeds are built

Definition at line 149 of file MsTrackFindingAlg.cxx.

                                                                                               {
        
        ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Attempt to fit a new track seed \n"<<seed);
        const EventContext& ctx{*calContext.get<const EventContext*>()};
        const auto [initialPars, measurements] = prepareFit(tgContext, calContext, seed);
        
        if (!initialPars.ok()) {
            ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Failed to construct valid parameters for seed \n"<<seed);
            if (m_visualizationTool.isEnabled()) {
                m_visualizationTool->displayTrackSeedObj(ctx, seed, initialPars, "FailedStartPars");
            }
            return false;
        }
        auto fitTraject = m_trackFitTool->fit(measurements, *initialPars, 
                                              tgContext, mfContext, calContext, 
                                              &(*initialPars).referenceSurface());
        if (!fitTraject || fitTraject->size() == 0) {
            ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Fit failed. Seed was \n"<<seed);
            if (m_visualizationTool.isEnabled()) {
                m_visualizationTool->displayTrackSeedObj(ctx, seed, initialPars, "FailedFit");
            }
            return false;
        }
 
        ActsTrk::MutableTrackContainer::TrackProxy track = fitTraject->getTrack(0);
        // Check the hit counts on track post fit and if we only have one station on track discard track
        // Eventually we should implement some recovery mechanism for track where we loose too many stations
        MuonR4::HitSummary summary = m_summaryTool->makeSummary(ctx, track);
        ATH_MSG_DEBUG("Track has " << static_cast<std::uint32_t>(summary.nPrecisionStations()) << " precision layers with summary "<< summary);
        if(summary.nPrecisionStations()<2) {
            ATH_MSG_DEBUG("rejecting single station track");
            return false;
        }
        if (!expressAtCaloExit(ctx, track)) {
 
            return false;
        }
        
        {
            fitTraject->addColumn<std::vector<const xAOD::MuonSegment*>>("muonSegLinks");
            auto appendMe = seed.segments();
            auto& toAppend = track.component<std::vector<const xAOD::MuonSegment*>>("muonSegLinks");
            toAppend.insert(toAppend.end(), appendMe.begin(), appendMe.end());
        }
        outContainer.ensureDynamicColumns(*fitTraject);
        auto destProxy = outContainer.getTrack(outContainer.addTrack());
        destProxy.copyFrom(track);
        ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Good track fit...");
        if (m_visualizationTool.isEnabled()) {
            m_visualizationTool->displayTrackSeedObj(ctx, seed, 
                destProxy.createParametersAtReference(), "GoodFit");
        }
        return true;
    }

◆ initialize()

StatusCode MuonR4::MsTrackFindingAlg::initialize ( )

finaloverridevirtual

Standard algorithm hook to setup the extrapolator, retrieve the tools and declare algorithm's data dependencies.

Definition at line 34 of file MsTrackFindingAlg.cxx.

                                             {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(detStore()->retrieve(m_detMgr));
        ATH_CHECK(m_msTrkSeedKey.initialize(SG::AllowEmpty));
 
        ATH_CHECK(m_visualizationTool.retrieve(EnableTool{!m_visualizationTool.empty()}));
        ATH_CHECK(m_trackFitTool.retrieve());
        ATH_CHECK(m_calibTool.retrieve());
        ATH_CHECK(m_writeKey.initialize());
        ATH_CHECK(m_summaryTool.retrieve());
        ATH_CHECK(m_seedingTool.retrieve());
        ATH_CHECK(m_extrapolationTool.retrieve(EnableTool{m_expressAtMsEntrance}));
        ATH_CHECK(m_trackingGeometrySvc.retrieve());
 
        ATH_CHECK(m_ctxProvider.initialize());
        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;
  }

◆ 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.

◆ prepareFit()

std::pair< MsTrackFindingAlg::OptBoundPars_t, MsTrackFindingAlg::MeasVec_t > MuonR4::MsTrackFindingAlg::prepareFit	(	const Acts::GeometryContext &	tgContext,
		const Acts::CalibrationContext &	calContext,
		const MsTrackSeed &	seed ) const

private

Prepares the input to the fit by collecting the measurements on the segment &.

Parameters

tgContext	Geometry context to access the alignment of the surfaces
calContext	Calibration context to access the calibration constants from Store gate during the track state filling
seed	The seed of interest to fit

Ensure that the drift signs from the fit are stamped onto the Uncalibrated measurements

Definition at line 105 of file MsTrackFindingAlg.cxx.

                                                                     {
        const EventContext& ctx{*calContext.get<const EventContext*>()};        
        
        auto initialPars = m_seedingTool->estimateStartParameters(ctx, seed);
        if (!initialPars.ok()) {          
            ATH_MSG_WARNING(__func__<<"() "<<__LINE__
                            <<" - Start parameter creation failed. ");
            return std::make_pair(OptBoundPars_t::failure(std::make_error_code(std::errc::invalid_argument)),
                                  std::vector<const xAOD::UncalibratedMeasurement_v1*>{});
        }
        
        MeasVec_t measurements{};
        measurements.reserve(100);
        for (const xAOD::MuonSegment* segment : seed.segments()) {
            m_calibTool->stampSignsOnMeasurements(*segment);
            MeasVec_t segMeasurements = collectMeasurements(*segment, /*skipOutlier:*/ true);
            if (msgLvl(MSG::VERBOSE)) {
                std::stringstream sstr{};
                for (const xAOD::UncalibratedMeasurement* m : segMeasurements) {
                    const Acts::Surface& surf{xAOD::muonSurface(m)};
                    sstr<<" ***  "<<m_idHelperSvc->toString(xAOD::identify(m))
                        <<", "<<m->numDimensions()<<", "
                        <<", "<<surf.geometryId()<<" @ "<<Amg::toString(surf.localToGlobalTransform(tgContext))<<std::endl;
                }
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Fetch measurements from segment: "<<Amg::toString(segment->position())
                         <<", direction: "<<Amg::toString(segment->direction()) << " eta " << segment->direction().eta() << " phi " << segment->direction().phi() <<"\n"<<sstr.str());
            }
            measurements.insert(measurements.end(), 
                                std::make_move_iterator(segMeasurements.begin()),
                                std::make_move_iterator(segMeasurements.end()));
        }
 
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - "<<measurements.size()<<" measurements");
        if (measurements.empty()) {
            ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - No measurements were associated with seed "<<seed);
            return std::make_pair(OptBoundPars_t::failure(std::make_error_code(std::errc::invalid_argument)),
                                  std::vector<const xAOD::UncalibratedMeasurement_v1*>{});
        }
        return std::make_pair(std::move(initialPars),  std::move(measurements));
 
    }

◆ 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_calibTool

ToolHandle<ISpacePointCalibrator> MuonR4::MsTrackFindingAlg::m_calibTool {this, "Calibrator", ""}

private

Calibration tool to fill the track states.

Definition at line 89 of file MsTrackFindingAlg.h.

89{this, "Calibrator", ""};

◆ m_ctxProvider

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

private

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 99 of file MsTrackFindingAlg.h.

99{this};

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::MsTrackFindingAlg::m_detMgr {nullptr}

private

Pointer to the MuonDetectorManager.

Definition at line 81 of file MsTrackFindingAlg.h.

81{nullptr};

◆ 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_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_expressAtMsEntrance

Gaudi::Property<bool> MuonR4::MsTrackFindingAlg::m_expressAtMsEntrance {this, "expressAtMsEntrance", true}

private

Propagate the track at the MS entry and express its parameters.

Definition at line 95 of file MsTrackFindingAlg.h.

95{this, "expressAtMsEntrance", true};

◆ 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_extrapolationTool

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

private

Track extrapolation tool.

Definition at line 91 of file MsTrackFindingAlg.h.

91{this, "ExtrapolationTool" ,"" };

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::MsTrackFindingAlg::m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

IdHelperSvc to decode the Identifiers.

Definition at line 79 of file MsTrackFindingAlg.h.

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

◆ m_ignoreFailedMsEntrance

Gaudi::Property<bool> MuonR4::MsTrackFindingAlg::m_ignoreFailedMsEntrance {this, "ignoreFailedExtpMsEntrance", true}

private

Ignore failed track extrapolations to the entrance.

Definition at line 97 of file MsTrackFindingAlg.h.

97{this, "ignoreFailedExtpMsEntrance", true};

◆ m_msTrkSeedKey

SG::WriteHandleKey<MsTrackSeedContainer> MuonR4::MsTrackFindingAlg::m_msTrkSeedKey {this, "MsTrkSeedKey", "MsTrackSeeds"}

private

Temporary container write handle to push the seeds to store gate for later efficiency analysis.

Definition at line 83 of file MsTrackFindingAlg.h.

83{this, "MsTrkSeedKey", "MsTrackSeeds"};

◆ m_seedingTool

ToolHandle<ITrackSeedingTool> MuonR4::MsTrackFindingAlg::m_seedingTool {this, "SeedingTool", ""}

private

The track seeding tool to construct the seed candidates and to estimate the initial parameters.

Definition at line 85 of file MsTrackFindingAlg.h.

85{this, "SeedingTool", ""};

◆ m_summaryTool

ToolHandle<MuonR4::ITrackSummaryTool> MuonR4::MsTrackFindingAlg::m_summaryTool {this, "SummaryTool" , ""}

private

Handle to the muon summary tool.

Definition at line 103 of file MsTrackFindingAlg.h.

103{this, "SummaryTool" , ""};

◆ m_trackFitTool

ToolHandle<ActsTrk::IFitterTool> MuonR4::MsTrackFindingAlg::m_trackFitTool {this, "FittingTool", ""}

private

Track fitting tool.

Definition at line 87 of file MsTrackFindingAlg.h.

87{this, "FittingTool", ""};

◆ m_trackingGeometrySvc

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

private

Service handle to the tracking geometry service.

Definition at line 93 of file MsTrackFindingAlg.h.

93{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_visualizationTool

ToolHandle<MuonValR4::ITrackVisualizationTool> MuonR4::MsTrackFindingAlg::m_visualizationTool {this, "VisualizationTool", ""}

private

Visualization tool to debug the track finding.

Definition at line 101 of file MsTrackFindingAlg.h.

101{this, "VisualizationTool", ""};

◆ m_writeKey

SG::WriteHandleKey<ActsTrk::TrackContainer> MuonR4::MsTrackFindingAlg::m_writeKey {this, "TrackWriteKey", "MsTracks"}

private

Key to the output track container.

Definition at line 105 of file MsTrackFindingAlg.h.

105{this, "TrackWriteKey", "MsTracks"};

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

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MeasVec_t

◆ OptBoundPars_t

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ~MsTrackFindingAlg()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ expressAtCaloExit()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ fitSeedCandidate()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ prepareFit()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_calibTool

◆ m_ctxProvider

◆ m_detMgr

◆ m_detStore

◆ m_evtStore

◆ m_expressAtMsEntrance

◆ m_extendedExtraObjects

◆ m_extrapolationTool

◆ m_idHelperSvc

◆ m_ignoreFailedMsEntrance

◆ m_msTrkSeedKey

◆ m_seedingTool

◆ m_summaryTool

◆ m_trackFitTool

◆ m_trackingGeometrySvc

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_visualizationTool

◆ m_writeKey