MuonR4::FastReconstructionAlg Class Reference

Algorithm executing Phase-2 fast reconstruction. More...

#include <MuonFastReconstructionAlg.h>

Inheritance diagram for MuonR4::FastReconstructionAlg:

Collaboration diagram for MuonR4::FastReconstructionAlg:

Public Member Functions
virtual	~FastReconstructionAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
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	SpacePointContainerVec = FastReco::GlobalPatternFinder::SpacePointContainerVec
	Abrivation for a vector of space-point containers.
using	PatternVec = FastReco::GlobalPatternFinder::PatternVec
	Abrivation for a vector of global patterns.
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKeyArray< SpacePointContainer >	m_inSpacePoints {this, "InSpacePoints", {"MuonSpacePoints"}, "List of space point containers to read"}
	Keys of SpacePoint containers to read.
SG::WriteHandleKeyArray< SpacePointContainer >	m_outSpacePoints {this, "OutSpacePoints", {}, "List of space point containers to write"}
	Write handle key for the output buckets.
StringProperty	m_outSpacePointSuffix {this, "OutSpacePointSuffix", "FastReco", "Suffix to add to input space point container names to create the output ones, when not provided"}
	Suffix to add to the input space point container names to create the output container names, when not provided.
SG::WriteHandleKey< GlobalPatternContainer >	m_outPatterns {this, "OutPatternContainer", "R4MuonGlobalPatterns"}
	Write handle key for the output global patterns.
SG::WriteHandleKey< xAOD::MuonContainer >	m_outMuons {this, "OutMuons", "R4FastRecoSAMuons", "List of fast muon containers to write"}
	Write handle key for the output Fast Reco SA muons.
ActsTrk::GeoContextReadKey_t	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Geometry context key.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Handle to the MuonIdHelper service.
ToolHandle< ISpacePointCalibrator >	m_calibTool {this, "Calibrator", "" }
	Handle to the space point calibrator tool.
ToolHandle< MuonValR4::IFastRecoVisualizationTool >	m_patVisionTool {this, "VisualizationTool", ""}
	Handle to the visualization tool for global patterns.
ToolHandle< MuonValR4::IPatternVisualizationTool >	m_segVisionTool {this, "SegmentVisualizationTool", ""}
	Handle to the visualization tool for segments.
ToolHandle< ITrackSeedingTool >	m_seedingTool {this, "SeedingTool", ""}
	The track seeding tool to construct the seed candidates and to estimate the initial parameters.
BooleanProperty	m_useMdtHits {this, "UseMdtHits", true, "Activate the utilization of MDT hits to build patterns"}
	--------------— Configuration options for the global pattern finder --------------—
BooleanProperty	m_seedFromMdt {this, "SeedFromMdt", false, "Activate the seeding from MDT hits"}
	Toggle the seeding from MDT hits.
BooleanProperty	m_seedFromInner {this, "SeedFromInner", false, "Activate the seeding from Inner station"}
	Activate the seeding from Inner station.
DoubleProperty	m_thetaSearchWindow {this, "ThetaWindowSearch", 0.06, "Size of the search window in theta to link hits to a pattern"}
	Size of theta window [rad] to search for compatible hits with a seed, tailored to the target pt cutoff.
DoubleProperty	m_baseResidualSigma {this, "BaseResidualSigma", 35, "Effective isotropic position uncertainty [mm], including detector resolution and unmodelled effects"}
	Effective isotropic position uncertainty [mm], including detector resolution and unmodelled effects.
DoubleProperty	m_phiTolerance {this, "PhiTolerance", 0.05, "Maximum allowed phi difference between two hits to be considered compatible"}
	Maximum phi difference [rad] allowed between two hits belonging to the same pattern.
UnsignedIntegerProperty	m_minTriggerLayers {this, "MinBendingTriggerLayers", 2, "Minimum number of trigger layers in the bending direction required to accept a pattern"}
	Requirement on trigger layers in the bending direction to accept a pattern.
UnsignedIntegerProperty	m_minPrecisionLayers {this, "MinBendingPrecisionLayers", 8, "Minimum number of precision layers in the bending direction required to accept a pattern"}
	Requirement on precision layers in the bending direction to accept a pattern.
UnsignedIntegerProperty	m_minPhiLayers {this, "MinPhiLayers", 1, "Minimum number of phi layers required to accept a pattern"}
	Minimum number of phi layers required to accept a pattern.
UnsignedIntegerProperty	m_minStationLayers {this, "MinStationLayers", 5, "Minimum number of layers in a station to be considered a good station"}
	Minimum number of layers in a station to be considered a good station.
DoubleProperty	m_meanNormRes2Cut {this, "meanNormRes2Cut", 0.2, "Quality cut on pattern'mean squared normalized residual"}
	Quality cut on pattern'mean squared normalized residual.
UnsignedIntegerProperty	m_maxSeedAttempts {this, "MaxSeedAttempts", 3, " Maximum number of attempts to build a pattern from hits already used in existing patterns"}
	Maximum number of attempts to build a pattern from hits already used in existing patterns.
UnsignedIntegerProperty	m_maxMissLayersInStation {this, "MaxMissedLayerHits", 3, "Maximum number of missed candidate hits in different measurement layers during pattern building allowed for a pattern branch before it is discarded"}
	Maximum number of missed candidate hits in different measurement layers during pattern building allowed for a pattern branch before it is discarded.
DoubleProperty	m_minHitDistance4Line {this, "MinHitDistance4Line",40, "Minimum distance (in mm) between two hits for being used to compute a reliable pattern line. Use the beamspot otherwise."}
	Minimum distance [mm] between two hits for being used to compute a reliable pattern line.
BooleanProperty	m_recalibInFit {this, "recalibInFit" , false}
	-----------------------— Configuration options for segment fitter ----------------------—
BooleanProperty	m_hessianResidual {this, "useHessianResidual", false}
	Use the expliciit Hessian in the residual calculation.
DoubleProperty	m_seedHitChi2 {this, "ResoSeedHitAssoc", 5. }
	Two mdt seeds are the same if their defining parameters match wihin.
BooleanProperty	m_recalibSeed {this, "SeedRecalibrate", false}
	Toggle seed recalibration.
DoubleProperty	m_goodSegmentCut {this, "GoodSegmentCut", 2.}
	Reduced chi2 defining a good segment, stopping the fit of other segments in the same station.
DoubleProperty	m_outlierRemovalCut {this, "OutlierRemoval", 3.}
	Cut on the segment chi2 / nDoF to launch the outlier removal.
DoubleProperty	m_recoveryPull {this, "RecoveryPull", 3.}
	Pull value for hit recovery.
UnsignedIntegerProperty	m_precHitCut {this, "PrecHitCut" , 3}
	Minimum number of precision hits to accept the segment.
BooleanProperty	m_useFastFitter {this, "useFastFitter", false}
	Use the fast Mdt fitter where possible.
BooleanProperty	m_fastPreFitter {this, "useFastPreFitter", false}
	The fast fitter is treated as a pre fitter.
BooleanProperty	m_ignoreFailedPreFit {this, "ignoreFailedPreFit", false}
	Switch to try the full fit when the fast pre-fitter fails.
UnsignedIntegerProperty	m_maxIter {this, "maxIterations", 50}
	Tune the number of iterations.
std::unique_ptr< FastReco::GlobalPatternFinder >	m_globPatFinder {}
	Pointer to the actual global pattern finder.
std::unique_ptr< FastReco::FastMuonSABuilder >	m_saBuilder {}
	Pointer to the FastMuonSABuilder.
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

Algorithm executing Phase-2 fast reconstruction.

This algorithm performs the Phase-2 fast reconstruction stage before the precision tracking in the Phase-2 Event Filter. It receives as input the collection of space-point containers and produces """"to be defined""" muon objects, which will be used to perform trigger decisions and be combined with InnerDetector tracks in the Combined Fast Reconstruction step. It will optionally write the GlobalPattern objects into the event store. The algorithm builds global patterns through the standalone module GlobalPatternFinder, fits segments in each station and use them to estimate the muon momentum.

Definition at line 34 of file MuonFastReconstructionAlg.h.

Member Typedef Documentation

PatternVec

using MuonR4::FastReconstructionAlg::PatternVec = FastReco::GlobalPatternFinder::PatternVec

private

Abrivation for a vector of global patterns.

Definition at line 46 of file MuonFastReconstructionAlg.h.

SpacePointContainerVec

using MuonR4::FastReconstructionAlg::SpacePointContainerVec = FastReco::GlobalPatternFinder::SpacePointContainerVec

private

Abrivation for a vector of space-point containers.

Definition at line 44 of file MuonFastReconstructionAlg.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~FastReconstructionAlg()

virtual MuonR4::FastReconstructionAlg::~FastReconstructionAlg ( )

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.

{ return m_detStore; }

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::FastReconstructionAlg::execute ( const EventContext & ctx ) const

overridevirtual

Write out the filtered spacepoint containers, i.e. those having a pattern

Write out the global patterns.

Definition at line 122 of file MuonFastReconstructionAlg.cxx.

                                                                       {
    SpacePointContainerVec inSpacePoints{};
    inSpacePoints.reserve(m_inSpacePoints.size());
    for (const auto& key: m_inSpacePoints) {
        auto& spc = inSpacePoints.emplace_back(nullptr);
        ATH_CHECK(SG::get(spc, key, ctx));
        ATH_MSG_DEBUG("Reading " << spc->size() << " SP buckets from collection: " << key);
    }
 
    const ActsTrk::GeometryContext* gctx{nullptr};
    ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
 
    using BucketPerContainer = GlobalPatternFinder::BucketPerContainer;
    BucketPerContainer outBuckets{};
    for (const SpacePointContainer* inSpc : inSpacePoints) {
        outBuckets.emplace(inSpc, BucketPerContainer::mapped_type{});
    }
    PatternVec patterns {m_globPatFinder->findPatterns(*gctx, inSpacePoints, outBuckets)};

    for (size_t idx = 0; idx < inSpacePoints.size(); ++idx) {
        const SpacePointContainer* inSpc = inSpacePoints.at(idx);
        const auto& outBucketVec = outBuckets.at(inSpc);
 
        SG::WriteHandle<SpacePointContainer> writeHandle{m_outSpacePoints.at(idx), ctx};
        ATH_CHECK(writeHandle.record(std::make_unique<SpacePointContainer>()));
 
        for (const SpacePointBucket* bucket : outBucketVec) {
            writeHandle->push_back(std::make_unique<SpacePointBucket>(*bucket));
        }
 
        ATH_MSG_DEBUG("Written " << writeHandle->size()
                        << " SP Buckets into StoreGate with key "
                        << m_outSpacePoints.at(idx));
    }
    SG::WriteHandle<GlobalPatternContainer> patWriteHandle{m_outPatterns, ctx};
    ATH_CHECK(patWriteHandle.record(std::make_unique<GlobalPatternContainer>()));
    for (GlobalPattern& pat : patterns) {
        patWriteHandle->push_back(std::make_unique<GlobalPattern>(std::move(pat)));
    }
    ATH_MSG_DEBUG("Written "<<patWriteHandle->size()<<" GlobalPatterns into StoreGate.");
 
    /* Build Fast Reco SA muons */
    FastMuonSABuilder::MuonCont_t fillMuons;
    ATH_CHECK(fillMuons.record(m_outMuons, ctx));
    std::size_t patIdx{0};
    using Patternlink = ElementLink<GlobalPatternContainer>;
    SG::Accessor<Patternlink> acc{patternLinkStr};
    for (const GlobalPattern* pat : *patWriteHandle) {
 
        xAOD::Muon* newMuon {m_saBuilder->buildMuonCandidate(ctx, *gctx, *pat, fillMuons)};
        if (!newMuon) {
            ATH_MSG_DEBUG("No muon candidate could be built for pattern " << *pat);
            patIdx++;
            continue;
        }
        // Add the link to the global pattern to the muon
        acc(*newMuon) = Patternlink{*patWriteHandle, patIdx};
        ATH_MSG_DEBUG("Add new muon candidate: " << printMuon(*newMuon));
        patIdx++;
    }
    ATH_MSG_DEBUG("Written "<<fillMuons->size()<<" FastMuonSA into StoreGate.");
    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();
  }

initialize()

StatusCode MuonR4::FastReconstructionAlg::initialize ( )

overridevirtual

Definition at line 27 of file MuonFastReconstructionAlg.cxx.

                                             {
    if (m_outSpacePoints.size() != m_inSpacePoints.size()) {
        m_outSpacePoints.clear();
        for (const auto& key: m_inSpacePoints) {
            m_outSpacePoints.emplace_back(key.key() + m_outSpacePointSuffix);
        }
    }
    ATH_CHECK(m_inSpacePoints.initialize());
    ATH_CHECK(m_outSpacePoints.initialize());
    ATH_CHECK(m_outPatterns.initialize());
    ATH_CHECK(m_outMuons.initialize());
 
    ATH_CHECK(m_geoCtxKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_calibTool.retrieve());
    ATH_CHECK(m_patVisionTool.retrieve(EnableTool{!m_patVisionTool.empty()}));
    ATH_CHECK(m_segVisionTool.retrieve(EnableTool{!m_segVisionTool.empty()}));
    ATH_CHECK(m_seedingTool.retrieve());
 
    GlobalPatternFinder::Config patCfg{};
    patCfg.useMdtHits = m_useMdtHits;
    patCfg.seedFromMdt = m_seedFromMdt;
    patCfg.thetaSearchWindow = m_thetaSearchWindow;
    patCfg.baseResidualSigma = m_baseResidualSigma;
    patCfg.phiTolerance = m_phiTolerance;
    patCfg.minTriggerLayers = m_minTriggerLayers;
    patCfg.minPrecisionLayers = m_minPrecisionLayers;
    patCfg.minPhiLayers = m_minPhiLayers;
    patCfg.minStationLayers = m_minStationLayers;
    patCfg.meanNormRes2Cut = m_meanNormRes2Cut;
    patCfg.maxSeedAttempts = m_maxSeedAttempts;
    patCfg.maxMissLayersInStation = m_maxMissLayersInStation;
    patCfg.minHitDistance4Line = m_minHitDistance4Line;
 
    if (m_seedFromInner) {
        patCfg.layerSeedings.push_back(LayerIndex::Inner);
    }
    patCfg.visionTool = m_patVisionTool.get();
    patCfg.idHelperSvc = m_idHelperSvc.get();
    m_globPatFinder = std::make_unique<GlobalPatternFinder>(name(), std::move(patCfg));
 
    FastMuonSABuilder::Config saCfg{};
    saCfg.recalibInFit = m_recalibInFit;
    saCfg.useHessianResidual = m_hessianResidual;
    saCfg.seedHitChi2 = m_seedHitChi2;
    saCfg.recalibSeed = m_recalibSeed;
    saCfg.goodSegmentCut = m_goodSegmentCut;
    saCfg.outlierRemovalCut = m_outlierRemovalCut;
    saCfg.recoveryPull = m_recoveryPull;
    saCfg.precHitCut= m_precHitCut;
    saCfg.useFastFitter = m_useFastFitter;
    saCfg.fastPreFitter = m_fastPreFitter;
    saCfg.ignoreFailedPreFit = m_ignoreFailedPreFit;
    saCfg.maxIter = m_maxIter;
 
    saCfg.calibrator = m_calibTool.get();
    saCfg.visionTool = m_segVisionTool.get();
    saCfg.idHelperSvc = m_idHelperSvc.get();
    saCfg.trackSeeder = m_seedingTool.get();
    m_saBuilder = std::make_unique<FastMuonSABuilder>(name(), std::move(saCfg));
 
    //Print Configuration
    ATH_MSG_DEBUG("Global Pattern Finder Configuration:\n"
            << " Theta search window [rad]: " << m_thetaSearchWindow << "\n"
            << " Base residual sigma [mm]: " << m_baseResidualSigma << "\n"
            << " Max missed layer hits in station: " << m_maxMissLayersInStation << "\n"
            << " Min hit distance for line [mm]: " << m_minHitDistance4Line << "\n"
            << " Phi tolerance [rad]: " << m_phiTolerance << "\n"
            << " Min trigger layers: " << m_minTriggerLayers << "\n"
            << " Min precision layers: " << m_minPrecisionLayers << "\n"
            << " Min phi layers: " << m_minPhiLayers << "\n"
            << " Min station layers: " << m_minStationLayers << "\n"
            << " Mean norm residual^2 cut: " << m_meanNormRes2Cut << "\n"
            << " Seed from inner: " << m_seedFromInner << "\n"
            << " Use MDT hits: " << m_useMdtHits << "\n"
            << " Seed from MDT: " << m_seedFromMdt << "\n"
            << " Max seed attempts: " << m_maxSeedAttempts << "\n");
    
    ATH_MSG_DEBUG("FastMuonSABuilder Configuration:\n"
            << " Recalibrate in fit: " << m_recalibInFit << "\n"
            << " Use Hessian in residual: " << m_hessianResidual << "\n"
            << " Seed hit chi2: " << m_seedHitChi2 << "\n"
            << " Recalibrate seed: " << m_recalibSeed << "\n"
            << " Good segment cut (reduced chi2): " << m_goodSegmentCut << "\n"
            << " Outlier removal cut (chi2/nDoF): " << m_outlierRemovalCut << "\n"
            << " Recovery pull: " << m_recoveryPull << "\n"
            << " Precision hit cut: " << m_precHitCut << "\n"
            << " Use fast fitter: " << m_useFastFitter << "\n"
            << " Fast fitter as pre-fitter: " << m_fastPreFitter << "\n"
            << " Ignore failed pre-fits: " << m_ignoreFailedPreFit << "\n"
            << " Max iterations: " << m_maxIter);
 
    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.

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_baseResidualSigma

DoubleProperty MuonR4::FastReconstructionAlg::m_baseResidualSigma {this, "BaseResidualSigma", 35, "Effective isotropic position uncertainty [mm], including detector resolution and unmodelled effects"}

private

Effective isotropic position uncertainty [mm], including detector resolution and unmodelled effects.

Definition at line 81 of file MuonFastReconstructionAlg.h.

{this, "BaseResidualSigma", 35, "Effective isotropic position uncertainty [mm], including detector resolution and unmodelled effects"};

m_calibTool

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

private

Handle to the space point calibrator tool.

Definition at line 63 of file MuonFastReconstructionAlg.h.

{this, "Calibrator", "" };

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_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_fastPreFitter

BooleanProperty MuonR4::FastReconstructionAlg::m_fastPreFitter {this, "useFastPreFitter", false}

private

The fast fitter is treated as a pre fitter.

Definition at line 122 of file MuonFastReconstructionAlg.h.

{this, "useFastPreFitter", false};

m_geoCtxKey

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

private

Geometry context key.

Definition at line 59 of file MuonFastReconstructionAlg.h.

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

m_globPatFinder

std::unique_ptr<FastReco::GlobalPatternFinder> MuonR4::FastReconstructionAlg::m_globPatFinder {}

private

Pointer to the actual global pattern finder.

Definition at line 131 of file MuonFastReconstructionAlg.h.

{};

m_goodSegmentCut

DoubleProperty MuonR4::FastReconstructionAlg::m_goodSegmentCut {this, "GoodSegmentCut", 2.}

private

Reduced chi2 defining a good segment, stopping the fit of other segments in the same station.

Definition at line 112 of file MuonFastReconstructionAlg.h.

{this, "GoodSegmentCut", 2.};

m_hessianResidual

BooleanProperty MuonR4::FastReconstructionAlg::m_hessianResidual {this, "useHessianResidual", false}

private

Use the expliciit Hessian in the residual calculation.

Definition at line 105 of file MuonFastReconstructionAlg.h.

{this, "useHessianResidual", false};

m_idHelperSvc

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

private

Handle to the MuonIdHelper service.

Definition at line 61 of file MuonFastReconstructionAlg.h.

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

m_ignoreFailedPreFit

BooleanProperty MuonR4::FastReconstructionAlg::m_ignoreFailedPreFit {this, "ignoreFailedPreFit", false}

private

Switch to try the full fit when the fast pre-fitter fails.

Definition at line 124 of file MuonFastReconstructionAlg.h.

{this, "ignoreFailedPreFit", false};

m_inSpacePoints

SG::ReadHandleKeyArray<SpacePointContainer> MuonR4::FastReconstructionAlg::m_inSpacePoints {this, "InSpacePoints", {"MuonSpacePoints"}, "List of space point containers to read"}

private

Keys of SpacePoint containers to read.

Definition at line 49 of file MuonFastReconstructionAlg.h.

{this, "InSpacePoints", {"MuonSpacePoints"}, "List of space point containers to read"};

m_maxIter

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_maxIter {this, "maxIterations", 50}

private

Tune the number of iterations.

Definition at line 126 of file MuonFastReconstructionAlg.h.

{this, "maxIterations", 50};

m_maxMissLayersInStation

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_maxMissLayersInStation {this, "MaxMissedLayerHits", 3, "Maximum number of missed candidate hits in different measurement layers during pattern building allowed for a pattern branch before it is discarded"}

private

Maximum number of missed candidate hits in different measurement layers during pattern building allowed for a pattern branch before it is discarded.

Definition at line 97 of file MuonFastReconstructionAlg.h.

{this, "MaxMissedLayerHits", 3, "Maximum number of missed candidate hits in different measurement layers during pattern building allowed for a pattern branch before it is discarded"};

m_maxSeedAttempts

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_maxSeedAttempts {this, "MaxSeedAttempts", 3, " Maximum number of attempts to build a pattern from hits already used in existing patterns"}

private

Maximum number of attempts to build a pattern from hits already used in existing patterns.

Definition at line 95 of file MuonFastReconstructionAlg.h.

{this, "MaxSeedAttempts", 3, " Maximum number of attempts to build a pattern from hits already used in existing patterns"};

m_meanNormRes2Cut

DoubleProperty MuonR4::FastReconstructionAlg::m_meanNormRes2Cut {this, "meanNormRes2Cut", 0.2, "Quality cut on pattern'mean squared normalized residual"}

private

Quality cut on pattern'mean squared normalized residual.

Set to a large value to disable the cut, e.g. 10.

Definition at line 93 of file MuonFastReconstructionAlg.h.

{this, "meanNormRes2Cut", 0.2, "Quality cut on pattern'mean squared normalized residual"};

m_minHitDistance4Line

DoubleProperty MuonR4::FastReconstructionAlg::m_minHitDistance4Line {this, "MinHitDistance4Line",40, "Minimum distance (in mm) between two hits for being used to compute a reliable pattern line. Use the beamspot otherwise."}

private

Minimum distance [mm] between two hits for being used to compute a reliable pattern line.

Use the beamspot otherwise.

Definition at line 99 of file MuonFastReconstructionAlg.h.

{this, "MinHitDistance4Line",40, "Minimum distance (in mm) between two hits for being used to compute a reliable pattern line. Use the beamspot otherwise."};

m_minPhiLayers

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minPhiLayers {this, "MinPhiLayers", 1, "Minimum number of phi layers required to accept a pattern"}

private

Minimum number of phi layers required to accept a pattern.

Definition at line 89 of file MuonFastReconstructionAlg.h.

{this, "MinPhiLayers", 1, "Minimum number of phi layers required to accept a pattern"};

m_minPrecisionLayers

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minPrecisionLayers {this, "MinBendingPrecisionLayers", 8, "Minimum number of precision layers in the bending direction required to accept a pattern"}

private

Requirement on precision layers in the bending direction to accept a pattern.

Definition at line 87 of file MuonFastReconstructionAlg.h.

{this, "MinBendingPrecisionLayers", 8, "Minimum number of precision layers in the bending direction required to accept a pattern"};

m_minStationLayers

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minStationLayers {this, "MinStationLayers", 5, "Minimum number of layers in a station to be considered a good station"}

private

Minimum number of layers in a station to be considered a good station.

Definition at line 91 of file MuonFastReconstructionAlg.h.

{this, "MinStationLayers", 5, "Minimum number of layers in a station to be considered a good station"};

m_minTriggerLayers

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minTriggerLayers {this, "MinBendingTriggerLayers", 2, "Minimum number of trigger layers in the bending direction required to accept a pattern"}

private

Requirement on trigger layers in the bending direction to accept a pattern.

Definition at line 85 of file MuonFastReconstructionAlg.h.

{this, "MinBendingTriggerLayers", 2, "Minimum number of trigger layers in the bending direction required to accept a pattern"};

m_outlierRemovalCut

DoubleProperty MuonR4::FastReconstructionAlg::m_outlierRemovalCut {this, "OutlierRemoval", 3.}

private

Cut on the segment chi2 / nDoF to launch the outlier removal.

Definition at line 114 of file MuonFastReconstructionAlg.h.

{this, "OutlierRemoval", 3.};

m_outMuons

SG::WriteHandleKey<xAOD::MuonContainer> MuonR4::FastReconstructionAlg::m_outMuons {this, "OutMuons", "R4FastRecoSAMuons", "List of fast muon containers to write"}

private

Write handle key for the output Fast Reco SA muons.

Definition at line 57 of file MuonFastReconstructionAlg.h.

{this, "OutMuons", "R4FastRecoSAMuons", "List of fast muon containers to write"};

m_outPatterns

SG::WriteHandleKey<GlobalPatternContainer> MuonR4::FastReconstructionAlg::m_outPatterns {this, "OutPatternContainer", "R4MuonGlobalPatterns"}

private

Write handle key for the output global patterns.

Definition at line 55 of file MuonFastReconstructionAlg.h.

{this, "OutPatternContainer", "R4MuonGlobalPatterns"};

m_outSpacePoints

SG::WriteHandleKeyArray<SpacePointContainer> MuonR4::FastReconstructionAlg::m_outSpacePoints {this, "OutSpacePoints", {}, "List of space point containers to write"}

private

Write handle key for the output buckets.

Definition at line 51 of file MuonFastReconstructionAlg.h.

{this, "OutSpacePoints", {}, "List of space point containers to write"};

m_outSpacePointSuffix

StringProperty MuonR4::FastReconstructionAlg::m_outSpacePointSuffix {this, "OutSpacePointSuffix", "FastReco", "Suffix to add to input space point container names to create the output ones, when not provided"}

private

Suffix to add to the input space point container names to create the output container names, when not provided.

Definition at line 53 of file MuonFastReconstructionAlg.h.

{this, "OutSpacePointSuffix", "FastReco", "Suffix to add to input space point container names to create the output ones, when not provided"};

m_patVisionTool

ToolHandle<MuonValR4::IFastRecoVisualizationTool> MuonR4::FastReconstructionAlg::m_patVisionTool {this, "VisualizationTool", ""}

private

Handle to the visualization tool for global patterns.

Definition at line 65 of file MuonFastReconstructionAlg.h.

{this, "VisualizationTool", ""};

m_phiTolerance

DoubleProperty MuonR4::FastReconstructionAlg::m_phiTolerance {this, "PhiTolerance", 0.05, "Maximum allowed phi difference between two hits to be considered compatible"}

private

Maximum phi difference [rad] allowed between two hits belonging to the same pattern.

Definition at line 83 of file MuonFastReconstructionAlg.h.

{this, "PhiTolerance", 0.05, "Maximum allowed phi difference between two hits to be considered compatible"};

m_precHitCut

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_precHitCut {this, "PrecHitCut" , 3}

private

Minimum number of precision hits to accept the segment.

Definition at line 118 of file MuonFastReconstructionAlg.h.

{this, "PrecHitCut" , 3};

m_recalibInFit

BooleanProperty MuonR4::FastReconstructionAlg::m_recalibInFit {this, "recalibInFit" , false}

private

-----------------------— Configuration options for segment fitter ----------------------—

Toggle the recalibration of hits during the segment fit

Definition at line 103 of file MuonFastReconstructionAlg.h.

{this, "recalibInFit" , false};

m_recalibSeed

BooleanProperty MuonR4::FastReconstructionAlg::m_recalibSeed {this, "SeedRecalibrate", false}

private

Toggle seed recalibration.

The two seed circles are recalibrated using the initial seed

Definition at line 110 of file MuonFastReconstructionAlg.h.

{this, "SeedRecalibrate", false};

m_recoveryPull

DoubleProperty MuonR4::FastReconstructionAlg::m_recoveryPull {this, "RecoveryPull", 3.}

private

Pull value for hit recovery.

Definition at line 116 of file MuonFastReconstructionAlg.h.

{this, "RecoveryPull", 3.};

m_saBuilder

std::unique_ptr<FastReco::FastMuonSABuilder> MuonR4::FastReconstructionAlg::m_saBuilder {}

private

Pointer to the FastMuonSABuilder.

Definition at line 133 of file MuonFastReconstructionAlg.h.

{};

m_seedFromInner

BooleanProperty MuonR4::FastReconstructionAlg::m_seedFromInner {this, "SeedFromInner", false, "Activate the seeding from Inner station"}

private

Activate the seeding from Inner station.

Definition at line 77 of file MuonFastReconstructionAlg.h.

{this, "SeedFromInner", false, "Activate the seeding from Inner station"};

m_seedFromMdt

BooleanProperty MuonR4::FastReconstructionAlg::m_seedFromMdt {this, "SeedFromMdt", false, "Activate the seeding from MDT hits"}

private

Toggle the seeding from MDT hits.

Definition at line 75 of file MuonFastReconstructionAlg.h.

{this, "SeedFromMdt", false, "Activate the seeding from MDT hits"};

m_seedHitChi2

DoubleProperty MuonR4::FastReconstructionAlg::m_seedHitChi2 {this, "ResoSeedHitAssoc", 5. }

private

Two mdt seeds are the same if their defining parameters match wihin.

Definition at line 107 of file MuonFastReconstructionAlg.h.

{this, "ResoSeedHitAssoc", 5. };

m_seedingTool

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

private

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

Definition at line 69 of file MuonFastReconstructionAlg.h.

{this, "SeedingTool", ""};

m_segVisionTool

ToolHandle<MuonValR4::IPatternVisualizationTool> MuonR4::FastReconstructionAlg::m_segVisionTool {this, "SegmentVisualizationTool", ""}

private

Handle to the visualization tool for segments.

Definition at line 67 of file MuonFastReconstructionAlg.h.

{this, "SegmentVisualizationTool", ""};

m_thetaSearchWindow

DoubleProperty MuonR4::FastReconstructionAlg::m_thetaSearchWindow {this, "ThetaWindowSearch", 0.06, "Size of the search window in theta to link hits to a pattern"}

private

Size of theta window [rad] to search for compatible hits with a seed, tailored to the target pt cutoff.

Definition at line 79 of file MuonFastReconstructionAlg.h.

{this, "ThetaWindowSearch", 0.06, "Size of the search window in theta to link hits to a pattern"};

m_useFastFitter

BooleanProperty MuonR4::FastReconstructionAlg::m_useFastFitter {this, "useFastFitter", false}

private

Use the fast Mdt fitter where possible.

Definition at line 120 of file MuonFastReconstructionAlg.h.

{this, "useFastFitter", false};

m_useMdtHits

BooleanProperty MuonR4::FastReconstructionAlg::m_useMdtHits {this, "UseMdtHits", true, "Activate the utilization of MDT hits to build patterns"}

private

--------------— Configuration options for the global pattern finder --------------—

Toggle the utilization of MDT hits to build patterns

Definition at line 73 of file MuonFastReconstructionAlg.h.

{this, "UseMdtHits", true, "Activate the utilization of MDT hits to build patterns"};

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.

---

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

• MuonFastReconstructionAlg.h
• MuonFastReconstructionAlg.cxx