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 unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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::ReadHandleKey< ActsTrk::GeometryContext >	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< MuonValR4::IFastRecoVisualizationTool >	m_visionTool {this, "VisualizationTool", ""}
	Handle to the visualization tool.
DoubleProperty	m_thetaSearchWindow {this, "ThetaWindowSearch", 0.04, "Size of the search window in theta to link hits to a pattern"}
	--------------— Configuration options for the global pattern finder --------------—
UnsignedIntegerProperty	m_maxMissedLayerHits {this, "MaxMissedLayerHits", 2, "Maximum number of missed candidate hits in different measurement layers during pattern building"}
	Maximum number of missed candidate hits in different measurement layers during pattern building.
DoubleProperty	m_baseRWindow {this, "BaseRWindow", 70, "Minimum allowed |R residual| between a test hit and the extrapolated line from the seed, evaluated at ΔZ = 0"}
	Base radial compatibility window (in mm).
DoubleProperty	m_minZDiff4Line {this, "MinZDiff4Line",10, "Minimum difference in global Z between the seed and the pattern hit to be used to compute the pattern line"}
	Minumum difference in global Z between the seed and the pattern hit to be used to compute the pattern line.
DoubleProperty	m_minRDiff4Line {this, "MinRDiff4Line",40, "Minimum difference in global R between the seed and the pattern hit to be used to compute the pattern line"}
	Minumum difference in global R between the seed and the pattern hit to be used to compute the pattern line.
DoubleProperty	m_phiTolerance {this, "PhiTolerance", 0.1, "Maximum allowed phi difference between two hits to be considered compatible"}
	Maximum phi difference in radiants allowed between two hits.
UnsignedIntegerProperty	m_minBendingTriggerHits {this, "MinBendingTriggerHits", 3, "Minimum number of trigger hits in the bending direction required to accept a pattern"}
	Requirement on trigger hits in the bending direction to accept a pattern.
UnsignedIntegerProperty	m_minBendingPrecisionHits {this, "MinBendingPrecisionHits", 0, "Minimum number of precision hits in the bending direction required to accept a pattern"}
	Requirement on precision hits in the bending direction to accept a pattern.
BooleanProperty	m_seedFromInner {this, "SeedFromInner", false, "Activate the seeding from Inner stations outward"}
	Activate the seeding from Inner stations outward.
BooleanProperty	m_useMdtHits {this, "UseMdtHits", true, "Activate the utilization of MDT hits to build patterns"}
	Toggle the utilization of MDT hits to build patterns.
BooleanProperty	m_seedFromMdt {this, "SeedFromMdt", false, "Activate the seeding from MDT hits"}
	Toggle the seeding from MDT hits.
UnsignedIntegerProperty	m_maxSeedAttempts {this, "MaxSeedAttempts", 2, " 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.
std::unique_ptr< FastReco::GlobalPatternFinder >	m_globPatFinder {}
	Pointer to the actual global pattern finder.
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 29 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 41 of file MuonFastReconstructionAlg.h.

SpacePointContainerVec

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

private

Abrivation for a vector of space-point containers.

Definition at line 39 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

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

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 48 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> writeHandle{m_outPatterns, ctx};
    ATH_CHECK(writeHandle.record(std::make_unique<GlobalPatternContainer>()));
    for (GlobalPattern& pat : patterns) {
        writeHandle->push_back(std::make_unique<GlobalPattern>(std::move(pat)));
    }
    ATH_MSG_DEBUG("Written "<<writeHandle->size()<<" GlobalPatterns 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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

initialize()

StatusCode MuonR4::FastReconstructionAlg::initialize ( )

overridevirtual

Definition at line 11 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_geoCtxKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_visionTool.retrieve(EnableTool{!m_visionTool.empty()}));
 
    GlobalPatternFinder::Config patCfg{};
    patCfg.thetaSearchWindow = m_thetaSearchWindow;
    patCfg.maxMissedLayerHits = m_maxMissedLayerHits;
    patCfg.baseRWindow = m_baseRWindow;
    patCfg.minZDiff4Line = m_minZDiff4Line;
    patCfg.minRDiff4Line = m_minRDiff4Line;
    patCfg.phiTolerance = m_phiTolerance;
    patCfg.minBendingTriggerHits = m_minBendingTriggerHits;
    patCfg.minBendingPrecisionHits = m_minBendingPrecisionHits;
    patCfg.useMdtHits = m_useMdtHits;
    patCfg.seedFromMdt = m_seedFromMdt;
    patCfg.maxSeedAttempts = m_maxSeedAttempts;
    if (m_seedFromInner) {
        patCfg.layerSeedings.push_back(LayerIndex::Inner);
    }
    patCfg.visionTool = m_visionTool.get();
    patCfg.idHelperSvc = m_idHelperSvc.get();
    m_globPatFinder = std::make_unique<GlobalPatternFinder>(name(), std::move(patCfg));
 
    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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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_baseRWindow

DoubleProperty MuonR4::FastReconstructionAlg::m_baseRWindow {this, "BaseRWindow", 70, "Minimum allowed |R residual| between a test hit and the extrapolated line from the seed, evaluated at ΔZ = 0"}

private

Base radial compatibility window (in mm).

This is the minimum allowed |R residual| between a test hit and the extrapolated line from the seed, evaluated at ΔZ = 0.

Definition at line 64 of file MuonFastReconstructionAlg.h.

{this, "BaseRWindow", 70, "Minimum allowed |R residual| between a test hit and the extrapolated line from the seed, evaluated at ΔZ = 0"};

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::FastReconstructionAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Geometry context key.

Definition at line 52 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 84 of file MuonFastReconstructionAlg.h.

{};

m_idHelperSvc

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

private

Handle to the MuonIdHelper service.

Definition at line 54 of file MuonFastReconstructionAlg.h.

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

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 44 of file MuonFastReconstructionAlg.h.

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

m_maxMissedLayerHits

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_maxMissedLayerHits {this, "MaxMissedLayerHits", 2, "Maximum number of missed candidate hits in different measurement layers during pattern building"}

private

Maximum number of missed candidate hits in different measurement layers during pattern building.

Definition at line 62 of file MuonFastReconstructionAlg.h.

{this, "MaxMissedLayerHits", 2, "Maximum number of missed candidate hits in different measurement layers during pattern building"};

m_maxSeedAttempts

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_maxSeedAttempts {this, "MaxSeedAttempts", 2, " 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 82 of file MuonFastReconstructionAlg.h.

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

m_minBendingPrecisionHits

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minBendingPrecisionHits {this, "MinBendingPrecisionHits", 0, "Minimum number of precision hits in the bending direction required to accept a pattern"}

private

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

Definition at line 74 of file MuonFastReconstructionAlg.h.

{this, "MinBendingPrecisionHits", 0, "Minimum number of precision hits in the bending direction required to accept a pattern"};

m_minBendingTriggerHits

UnsignedIntegerProperty MuonR4::FastReconstructionAlg::m_minBendingTriggerHits {this, "MinBendingTriggerHits", 3, "Minimum number of trigger hits in the bending direction required to accept a pattern"}

private

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

Definition at line 72 of file MuonFastReconstructionAlg.h.

{this, "MinBendingTriggerHits", 3, "Minimum number of trigger hits in the bending direction required to accept a pattern"};

m_minRDiff4Line

DoubleProperty MuonR4::FastReconstructionAlg::m_minRDiff4Line {this, "MinRDiff4Line",40, "Minimum difference in global R between the seed and the pattern hit to be used to compute the pattern line"}

private

Minumum difference in global R between the seed and the pattern hit to be used to compute the pattern line.

Definition at line 68 of file MuonFastReconstructionAlg.h.

{this, "MinRDiff4Line",40, "Minimum difference in global R between the seed and the pattern hit to be used to compute the pattern line"};

m_minZDiff4Line

DoubleProperty MuonR4::FastReconstructionAlg::m_minZDiff4Line {this, "MinZDiff4Line",10, "Minimum difference in global Z between the seed and the pattern hit to be used to compute the pattern line"}

private

Minumum difference in global Z between the seed and the pattern hit to be used to compute the pattern line.

Definition at line 66 of file MuonFastReconstructionAlg.h.

{this, "MinZDiff4Line",10, "Minimum difference in global Z between the seed and the pattern hit to be used to compute the pattern line"};

m_outPatterns

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

private

Write handle key for the output global patterns.

Definition at line 50 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 46 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 48 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_phiTolerance

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

private

Maximum phi difference in radiants allowed between two hits.

Definition at line 70 of file MuonFastReconstructionAlg.h.

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

m_seedFromInner

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

private

Activate the seeding from Inner stations outward.

Definition at line 76 of file MuonFastReconstructionAlg.h.

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

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 80 of file MuonFastReconstructionAlg.h.

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

m_thetaSearchWindow

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

private

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

Size of theta window in radiants to search for comapatible hits with a pattern, tailored to the target pt cutoff

Definition at line 60 of file MuonFastReconstructionAlg.h.

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

m_useMdtHits

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

private

Toggle the utilization of MDT hits to build patterns.

Definition at line 78 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.

m_visionTool

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

private

Handle to the visualization tool.

Definition at line 56 of file MuonFastReconstructionAlg.h.

{this, "VisualizationTool", ""};

---

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

• MuonFastReconstructionAlg.h
• MuonFastReconstructionAlg.cxx