MuonInDetToMuonSystemExtensionAlg Class Reference

The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg. More...

#include <MuonInDetToMuonSystemExtensionAlg.h>

Inheritance diagram for MuonInDetToMuonSystemExtensionAlg:

Collaboration diagram for MuonInDetToMuonSystemExtensionAlg:

Classes
struct	InDetCandidateCache
struct	MuidCoCache
	Helper struct to cache the MuidCo track and it's associated segments while keeping the association InDetCandidate <– > muidCo Tag. More...

Public Member Functions
	~MuonInDetToMuonSystemExtensionAlg ()=default
StatusCode	initialize () override
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	MuidCoVector = std::vector<MuidCoCache>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	selectCandidates (const EventContext &ctx, InDetCandidateCache &cache) const
	Select the MuidCo candidates and put the associated id tracks on a block list.
StatusCode	findHitSectors (const EventContext &ctx, InDetCandidateCache &output_cache) const
	Find the sectors in the MS with muon signals.
StatusCode	findSegments (const EventContext &ctx, InDetCandidateCache &output_cache) const
	Select good segments.
bool	hasMatchingSegment (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
	Searches for segments within theta < 0.2 && sharing the same sector.
bool	hasMatchingSeed (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
	Searches for hough seeds within theta < 0.2 && sharing the same sector.
StatusCode	create (const EventContext &ctx, InDetCandidateCache &cache) const
	Create the InDetCandidaes with system extensions.
StatusCode	createStaus (const EventContext &ctx, const InDetCandidateCollection *ext_candidates, const MuidCoVector &tag_map) const
void	maskHits (const Muon::MuonSegment *muon_seg, InDetCandidateCache &output_cache) const
	Mask the hits of the corresponding muon segment as used.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< InDetCandidateCollection >	m_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}
SG::WriteHandleKey< InDetCandidateCollection >	m_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}
	Collection of InDet candidates written for MuGirl and MuonSegmentTag.
SG::WriteHandleKey< InDetCandidateCollection >	m_stauInDetCandKey {this, "WriteStauCandidates", ""}
	Collection of InDet candidates written for MuGirlStau.
SG::ReadHandleKey< Muon::HoughDataPerSectorVec >	m_houghDataPerSectorVecKey
	Use the hough data to find sectors in the speectrometer traversed by a muon.
SG::ReadHandleKey< Trk::SegmentCollection >	m_segmentKey
	Let's exploit the segments to get rid of as much tracks as possible.
PublicToolHandle< Muon::IMuonSegmentSelectionTool >	m_segmentSelector
ToolHandle< Muon::IMuonSystemExtensionTool >	m_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}
	The system extension tool extrapolates the candidate through the spectrometer.
SG::ReadHandleKey< MuonCombined::InDetCandidateToTagMap >	m_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}
	That is the collection of MuidCo candidates.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
Gaudi::Property< bool >	m_restrictExtension {this, "UseOnlyHitSectors", false}
	Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded.
Gaudi::Property< int >	m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}
	The hough maxima always contain at least 2 hits.
Gaudi::Property< int >	m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}
Gaudi::Property< bool >	m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}
	Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates.
Gaudi::Property< float >	m_extThreshold {this, "ExtensionPtThreshold", 2500}
	Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer.
Gaudi::Property< bool >	m_extendSAF {this, "ExtendSAF", false}
	Shall SAF tracks be equiped with a muon system extension used by MuGirl later.
Gaudi::Property< bool >	m_extendBulk {this, "ExtendBulk", true}
	Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later.
const Muon::MuonSectorMapping	m_sector_mapping {}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg.

The idea is that the latter is only selecting the Id tracks based on the outcome of the Id selection tool and whether a CaloExtension could be successfully attached. This information is full sufficient to run the MuonCombinedAlg and the MuonCalo algorithms, but not the SegmentTagging or muGirl. InDetCandidates, not combined to a full muon track by MuidCo (STACO generates to much noise) are copied and then equipped with the muonSystem extension.

Definition at line 34 of file MuonInDetToMuonSystemExtensionAlg.h.

Member Typedef Documentation

MuidCoVector

using MuonInDetToMuonSystemExtensionAlg::MuidCoVector = std::vector<MuidCoCache>

private

Definition at line 76 of file MuonInDetToMuonSystemExtensionAlg.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~MuonInDetToMuonSystemExtensionAlg()

MuonInDetToMuonSystemExtensionAlg::~MuonInDetToMuonSystemExtensionAlg ( )

default

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;
}

create()

StatusCode MuonInDetToMuonSystemExtensionAlg::create ( const EventContext & ctx, InDetCandidateCache & cache ) const

private

Create the InDetCandidaes with system extensions.

We want these tracks to be extrapolated through the spectrometer reject those no meeting the basic requirements

Prepare the system extension

The candidate already has somehow a system extension --> it's just a matter of copying it

The system extension does not own the MuonEntryLayerIntersection()-> it's fine

If the id candidate has a matching segment, then we know that this track can be potentially reconstructed by MuTagIMO

Definition at line 100 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                  {
    for (const MuonCombined::InDetCandidate* candidate : *out_cache.input_candidates) {
        if (out_cache.excluded_trks.count(candidate)) {
            ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " has already been used by MuidCo");
            continue;
        }
        if (candidate->indetTrackParticle().pt() < m_extThreshold || (!m_extendSAF && candidate->isSiliconAssociated()) ||
            (!m_extendBulk && !candidate->isSiliconAssociated())) {
            ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " is too soft");
            continue;
        }

        Muon::IMuonSystemExtensionTool::SystemExtensionCache cache;
        cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(candidate->indetTrackParticleLink());
        cache.candidate->setSiliconAssociated(candidate->isSiliconAssociated());
        cache.candidate->setExtension(candidate->getCaloExtension());
 
        const Muon::MuonSystemExtension* extension = candidate->getExtension();
        if (extension) {
            std::vector<Muon::MuonSystemExtension::Intersection> intersects = extension->layerIntersections();
            cache.candidate->setExtension(
                std::make_unique<Muon::MuonSystemExtension>(&extension->muonEntryLayerIntersection(), std::move(intersects)));
        } else {
            const bool seg_match = !m_restrictExtension || hasMatchingSegment(*candidate, out_cache);
 
            if (!seg_match && !hasMatchingSeed(*candidate, out_cache)) continue;
            cache.useHitSectors = !seg_match;
            cache.sectorsWithHits = &out_cache.hit_sectors;
            cache.createSystemExtension = true;
            cache.requireSystemExtension = true;
 
            if (!m_muonSystemExtensionTool->muonSystemExtension(ctx, cache)) {
                ATH_MSG_VERBOSE("Extension failed");
                continue;
            }
        }
        out_cache.outputContainer->push_back(std::move(cache.candidate));
    }
    if (msgLevel(MSG::DEBUG)) {
        std::stringstream sstr;
        for (const MuonCombined::InDetCandidate* extended : *out_cache.outputContainer) {
            sstr << "   * " << extended->toString() << std::endl;
        }
        if (!out_cache.excluded_trks.empty()) {
            sstr << std::endl << " ======== The following tracks were already successfully combined  ======== " << std::endl;
            for (const MuonCombined::InDetCandidate* combined : out_cache.excluded_trks) {
                sstr << "   = " << combined->toString() << std::endl;
            }
        }
        if (out_cache.excluded_trks.size() + out_cache.outputContainer->size() != out_cache.input_candidates->size()) {
            sstr << std::endl << " ++++++++ The following candidates were not extrapolated  ++++++++  " << std::endl;
            const InDetCandidateCollection::const_iterator begin = out_cache.outputContainer->begin();
            const InDetCandidateCollection::const_iterator end = out_cache.outputContainer->end();
 
            for (const MuonCombined::InDetCandidate* rejected : *out_cache.input_candidates) {
                if (out_cache.excluded_trks.count(rejected) ||
                    std::find_if(begin, end,
                                 [rejected](const MuonCombined::InDetCandidate* extended) { return (*rejected) == (*extended); }) != end)
                    continue;
                sstr << "   + " << rejected->toString() << std::endl;
            }
        }
        ATH_MSG_DEBUG("Extrapolated " << out_cache.outputContainer->size() << " out of " << out_cache.input_candidates->size()
                                      << " tracks through the spectrometer" << std::endl
                                      << std::endl
                                      << sstr.str());
    }
    return StatusCode::SUCCESS;
}

createStaus()

StatusCode MuonInDetToMuonSystemExtensionAlg::createStaus ( const EventContext & ctx, const InDetCandidateCollection * ext_candidates, const MuidCoVector & tag_map ) const

private

This will copy the existing candidates to the new container without calling the system extension tool

For the staus it is quite unclear what is the overlap between MuidCo and MuGirlStau. So in order to be on the safe side we add the MuidCo candidate tracks as well, but we also try to avoid the extrapolator like a cat does for a bubble bath. By taking the perigee parameters of the associated muon segments, we have a much much shorter path to extrapolate the track to the MuonLayerInterSection surfaces.

Definition at line 337 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                             {
    if (m_stauInDetCandKey.empty()) {
        ATH_MSG_VERBOSE("No candidates for stau reconstruction will be written");
        return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("Now find the candidates to be considered for MuGirlStau");
    InDetCandidateCache stau_cache{};
    stau_cache.input_candidates = ext_candidates;

    ATH_CHECK(create(ctx, stau_cache));
    for (const MuidCoCache& idMuidCo : tag_map) {
        Muon::IMuonSystemExtensionTool::SystemExtensionCache cache;
        cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(idMuidCo.id_trk->indetTrackParticleLink());
        cache.candidate->setSiliconAssociated(idMuidCo.id_trk->isSiliconAssociated());
        cache.candidate->setExtension(idMuidCo.id_trk->getCaloExtension());
        cache.useHitSectors = false;
        cache.createSystemExtension = true;
        cache.requireSystemExtension = true;
 
        if (!m_muonSystemExtensionTool->muonLayerInterSections(ctx, *idMuidCo.cmb_trk, cache)) {
            ATH_MSG_DEBUG("Could not determine the intersections. Although that should be possible");
            continue;
        }
        stau_cache.outputContainer->push_back(std::move(cache.candidate));
    }
 
    SG::WriteHandle<InDetCandidateCollection> indetCandidateCollection(m_stauInDetCandKey, ctx);
    // sort candidates beofre storing, otherwise ordering in container of stau segments can be inconsistent
    std::sort(stau_cache.outputContainer->begin(),stau_cache.outputContainer->end(),[](const MuonCombined::InDetCandidate*a, const MuonCombined::InDetCandidate*b){
        return a->indetTrackParticle().pt() < b->indetTrackParticle().pt();});
    ATH_CHECK(indetCandidateCollection.record(std::move(stau_cache.outputContainer)));
    return StatusCode::SUCCESS;
}

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

override

Definition at line 47 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                   {
    ATH_MSG_DEBUG("Cakes are availablei in "<<ctx.eventID().event_number());
    InDetCandidateCache output_cache{};
 
    SG::ReadHandle<InDetCandidateCollection> input_container{m_inputCandidate, ctx};
    if (!input_container.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve " << m_inputCandidate.fullKey());
        return StatusCode::FAILURE;
    }
    output_cache.input_candidates = input_container.cptr();
    ATH_CHECK(selectCandidates(ctx, output_cache));
 
    if (m_restrictExtension) {
        ATH_CHECK(findSegments(ctx, output_cache));
        ATH_CHECK(findHitSectors(ctx, output_cache));
    }
 
    ATH_MSG_DEBUG("Find the inner detector candidates to be used for MuGirl / Segment tagging");
    ATH_CHECK(create(ctx, output_cache));
    SG::WriteHandle<InDetCandidateCollection> indetCandidateCollection(m_bulkInDetCandKey, ctx);
    ATH_CHECK(indetCandidateCollection.record(std::move(output_cache.outputContainer)));
 
    ATH_CHECK(createStaus(ctx, indetCandidateCollection.ptr(), output_cache.tag_map));
 
    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();
  }

findHitSectors()

StatusCode MuonInDetToMuonSystemExtensionAlg::findHitSectors ( const EventContext & ctx, InDetCandidateCache & output_cache ) const

private

Find the sectors in the MS with muon signals.

Helper function to cound whether all three stations are actually complete

The phi-hit vector has a size of 3 representing the forward-backward and barrel sections

Hits built into a MuidCo track

Subtract the hits used by MuidCo from the hough seeds

Find the chamber with the largest number of hits

Average the theta

Loop over the maxima & find the hit sectors

Remove all hits from the seed that are built into a segment

If the seed has still more than the minimum. Then let's mark the sector as hit

Cache the eta value additionally

Definition at line 177 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                             {
    SG::ReadHandle<Muon::HoughDataPerSectorVec> readHandle{m_houghDataPerSectorVecKey, ctx};
    if (!readHandle.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve the prep data container " << m_houghDataPerSectorVecKey.fullKey());
        return StatusCode::FAILURE;
    }
    const std::vector<Muon::HoughDataPerSec>& hough_data = readHandle->vec;
    auto count_finished = [&output_cache]() -> unsigned int {
        unsigned int n{0};
        for (const auto& sector_hits : output_cache.hit_sectors) { n += sector_hits.second.size() >= num_sectors; }
        return n;
    };

    using namespace Muon::MuonStationIndex;
    for (int det_region = 0; det_region < toInt(DetectorRegionIndex::DetectorRegionIndexMax); ++det_region) {
        const RegionIndex region_index = static_cast<RegionIndex>(det_region);
        for (int layer = 0; layer < toInt(LayerIndex::LayerIndexMax); ++layer) {
            const LayerIndex layer_index = static_cast<LayerIndex>(layer);
            const unsigned int hash = sectorLayerHash(region_index, layer_index);
            const std::set<Identifier>& masked_hits = output_cache.consumed_hits[hash];

            auto num_hough_hits = [&masked_hits, this](const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& hough_maximum) {
                std::map<Identifier, hough_chamber> chamber_counts;
                for (const std::shared_ptr<MuonHough::Hit>& hough_hit : hough_maximum->hits) {
                    const Trk::PrepRawData* prep = prepData(hough_hit);
                    const Identifier chId = prep->identify();
                    if (masked_hits.count(chId) || (m_excludeNSW && (m_idHelperSvc->isMM(chId) || m_idHelperSvc->issTgc(chId)))) {
                        ATH_MSG_VERBOSE("Do not reuse hit " << m_idHelperSvc->toString(chId));
                        continue;
                    }
                    ATH_MSG_VERBOSE("Count hough hit " << m_idHelperSvc->toString(chId));
                    // Split the seeds into the chambers
                    hough_chamber& chamber = chamber_counts[m_idHelperSvc->chamberId(chId)];
                    ++chamber.nhits;
                    const Amg::Vector3D glob_pos = prep->detectorElement()->center(chId);
                    chamber.eta += glob_pos.eta();
                    chamber.sectors.insert(m_sector_mapping.getSector(glob_pos.phi()));
                }
                hough_chamber N{};
                for (auto& ch_it : chamber_counts) {
                    if (N.nhits < ch_it.second.nhits) { N = std::move(ch_it.second); }
                }
                N.eta /= std::max(N.nhits, 1);
                return N;
            };
 
            for (const Muon::HoughDataPerSec& sector_data : hough_data) {
                const Muon::HoughDataPerSec::MaximumVec& eta_hits = sector_data.maxVec[hash];
                for (const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& maxima : eta_hits) {
                    const hough_chamber effect_hits = num_hough_hits(maxima);
                    if (m_houghMin > effect_hits.nhits) continue;
                    ATH_MSG_VERBOSE("Hough maximum in " << Muon::MuonStationIndex::regionName(region_index) << ", "
                                                        << Muon::MuonStationIndex::layerName(layer_index)
                                                        << ", hits: " << effect_hits.nhits);
 
                    for (const int sector : effect_hits.sectors) {
                        output_cache.hit_sectors[region_index].insert(sector);
                        output_cache.eta_seeds[sector].push_back(effect_hits.eta);
                    }
                }
                if (count_finished() >= toInt(RegionIndex::DetectorRegionIndexMax)) {
                    ATH_MSG_VERBOSE("The MS is filled up with Hough seeds. We do not need to search for them any longer");
                    break;
                }
            }
        }
        for (auto& theta_pair : output_cache.eta_seeds) { std::sort(theta_pair.second.begin(), theta_pair.second.end()); }
    }
    output_cache.consumed_hits.clear();
    return StatusCode::SUCCESS;
}

findSegments()

StatusCode MuonInDetToMuonSystemExtensionAlg::findSegments ( const EventContext & ctx, InDetCandidateCache & output_cache ) const

private

Select good segments.

Check if the segment is part of a MuidCo muon

Mask all hits from the Hough seeds

Definition at line 259 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                           {
    SG::ReadHandle<Trk::SegmentCollection> segmentContainer{m_segmentKey, ctx};
    if (!segmentContainer.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve the Muon segment container " << m_segmentKey.fullKey());
        return StatusCode::FAILURE;
    }
    for (const Trk::Segment* trk_segment : *segmentContainer) {
        // Which in reality is a Muon segment
        const Muon::MuonSegment* muon_segment = dynamic_cast<const Muon::MuonSegment*>(trk_segment);
        if (!muon_segment) {
            ATH_MSG_WARNING("How can it be that a Muon segment is not a muon segment?");
            continue;
        }
        // Check if the segment satisfies the quality criteria
        if (m_segmentSelector->quality(*muon_segment) < m_segmentQuality) continue;
        if (output_cache.combined_segs.count(muon_segment)) {
            ATH_MSG_VERBOSE("Segment was already used in combined fit");
            continue;
        }
        if (m_excludeNSW && std::find_if(muon_segment->containedMeasurements().begin(),muon_segment->containedMeasurements().end(),
                [this](const Trk::MeasurementBase* meas ){
                    const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
                     return meas_id.is_valid() && (m_idHelperSvc->isMM(meas_id) || m_idHelperSvc->issTgc(meas_id));
                })!= muon_segment->containedMeasurements().end()) continue;
        
        maskHits(muon_segment, output_cache);
        output_cache.candidate_segments.push_back(muon_segment);
    }
    output_cache.combined_segs.clear();
    return StatusCode::SUCCESS;
}

hasMatchingSeed()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSeed ( const MuonCombined::InDetCandidate & id_cand, const InDetCandidateCache & cache ) const

private

Searches for hough seeds within theta < 0.2 && sharing the same sector.

Definition at line 321 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                {
    const Trk::TrackParameters* ms_entry = id_cand.getCaloExtension()->muonEntryLayerIntersection();
    const double etaID = ms_entry->position().eta();
    std::vector<int> id_sectors;
    m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
    for (const int& sect : id_sectors) {
        std::map<int, std::vector<double>>::const_iterator theta_itr = cache.eta_seeds.find(sect);
        if (theta_itr == cache.eta_seeds.end()) continue;
        if (std::find_if(theta_itr->second.begin(), theta_itr->second.end(),
                         [&etaID](const double eta_seed) { return std::abs(etaID - eta_seed) < 0.1; }) != theta_itr->second.end())
            return true;
    }
    return false;
}

hasMatchingSegment()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSegment ( const MuonCombined::InDetCandidate & id_cand, const InDetCandidateCache & cache ) const

private

Searches for segments within theta < 0.2 && sharing the same sector.

Definition at line 292 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                   {
    const Trk::TrackParameters* ms_entry = id_cand.getCaloExtension()->muonEntryLayerIntersection();
    const double ThetaID = ms_entry->position().theta();
    std::vector<int> id_sectors;
    m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
    auto sector_match = [&id_sectors, this](const Amg::Vector3D& seg_pos) -> bool {
        std::vector<int> seg_sectors;
        m_sector_mapping.getSectors(seg_pos.phi(), seg_sectors);
        return std::find_if(id_sectors.begin(), id_sectors.end(), [&seg_sectors](const int id_sec) {
                   return std::find(seg_sectors.begin(), seg_sectors.end(), id_sec) != seg_sectors.end();
               }) != id_sectors.end();
    };
    for (const Muon::MuonSegment* itSeg : cache.candidate_segments) {
        const Amg::Vector3D pos = itSeg->globalPosition();
        const double dTheta = pos.theta() - ThetaID;
        const bool theta_match = std::abs(dTheta) < 0.2;
        if (!theta_match) {
            ATH_MSG_VERBOSE("dTheta cut failed");
            continue;
        }
        if (!sector_match(pos)) {
            ATH_MSG_VERBOSE("dPhi cut failed");
            continue;
        }
        return true;
    }
    return false;
}

initialize()

StatusCode MuonInDetToMuonSystemExtensionAlg::initialize ( )

override

Definition at line 32 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                         {
    ATH_CHECK(m_muonSystemExtensionTool.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_edmHelperSvc.retrieve());
    ATH_CHECK(m_combTagMap.initialize());
    ATH_CHECK(m_inputCandidate.initialize());
    ATH_CHECK(m_bulkInDetCandKey.initialize());
    ATH_CHECK(m_stauInDetCandKey.initialize(!m_stauInDetCandKey.empty()));
    if (m_restrictExtension) { ATH_MSG_INFO("Use the Hough seeds to determine the sectors in the MS worth for being extrapolated to"); }
    ATH_CHECK(m_houghDataPerSectorVecKey.initialize(m_restrictExtension));
    ATH_CHECK(m_segmentKey.initialize(m_restrictExtension));
    if (m_restrictExtension) { ATH_CHECK(m_segmentSelector.retrieve()); }
    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 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;
}

maskHits()

void MuonInDetToMuonSystemExtensionAlg::maskHits ( const Muon::MuonSegment * muon_seg, InDetCandidateCache & output_cache ) const

private

Mask the hits of the corresponding muon segment as used.

Definition at line 378 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                         {
    const Identifier seg_id = m_edmHelperSvc->chamberId(*muon_seg);
    const LayerIndex layer_index = m_idHelperSvc->layerIndex(seg_id);
    const RegionIndex region_index = m_idHelperSvc->regionIndex(seg_id);
    const unsigned int hash = Muon::MuonStationIndex::sectorLayerHash(region_index, layer_index);
    std::set<Identifier>& id_set = output_cache.consumed_hits[hash];
    for (const Trk::MeasurementBase* meas : muon_seg->containedMeasurements()) {
        const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
        id_set.insert(meas_id);
    }
}

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

selectCandidates()

StatusCode MuonInDetToMuonSystemExtensionAlg::selectCandidates ( const EventContext & ctx, InDetCandidateCache & cache ) const

private

Select the MuidCo candidates and put the associated id tracks on a block list.

Definition at line 73 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                            {
    SG::ReadHandle<MuonCombined::InDetCandidateToTagMap> tag_map{m_combTagMap, ctx};
    if (!tag_map.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve the tag map from " << tag_map.fullKey());
        return StatusCode::FAILURE;
    }
    if (tag_map->empty()) {
        ATH_MSG_DEBUG("No combined candidates in this event");
        return StatusCode::SUCCESS;
    }
 
    for (const auto& combined_tags : *tag_map) {
        if (combined_tags.second->author() != xAOD::Muon::MuidCo) {
            ATH_MSG_WARNING("Found a non MuidCo tag.... Please check " << combined_tags.second->toString());
            continue;
        }
        const MuonCombined::CombinedFitTag* cmb_tag = dynamic_cast<const MuonCombined::CombinedFitTag*>(combined_tags.second.get());
        MuidCoCache cache{combined_tags.first, cmb_tag};
        out_cache.tag_map.push_back(std::move(cache));
        out_cache.excluded_trks.insert(combined_tags.first);
        for (const Muon::MuonSegment* muon_seg : cmb_tag->associatedSegments()) {
            out_cache.combined_segs.insert(muon_seg);
            maskHits(muon_seg, out_cache);
        }
    }
    return StatusCode::SUCCESS;
}

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_bulkInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}

private

Collection of InDet candidates written for MuGirl and MuonSegmentTag.

Definition at line 46 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"};

m_combTagMap

SG::ReadHandleKey<MuonCombined::InDetCandidateToTagMap> MuonInDetToMuonSystemExtensionAlg::m_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}

private

That is the collection of MuidCo candidates.

Definition at line 63 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"};

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_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonInDetToMuonSystemExtensionAlg::m_edmHelperSvc

private

Initial value:

{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 67 of file MuonInDetToMuonSystemExtensionAlg.h.

                                                       {this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"};

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_excludeNSW

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}

private

Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates.

Definition at line 113 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"};

m_extendBulk

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendBulk {this, "ExtendBulk", true}

private

Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 119 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "ExtendBulk", true};

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_extendSAF

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendSAF {this, "ExtendSAF", false}

private

Shall SAF tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 117 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "ExtendSAF", false};

m_extThreshold

Gaudi::Property<float> MuonInDetToMuonSystemExtensionAlg::m_extThreshold {this, "ExtensionPtThreshold", 2500}

private

Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer.

Definition at line 115 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "ExtensionPtThreshold", 2500};

m_houghDataPerSectorVecKey

SG::ReadHandleKey<Muon::HoughDataPerSectorVec> MuonInDetToMuonSystemExtensionAlg::m_houghDataPerSectorVecKey

private

Initial value:

{this, "LayerHoughKey", "HoughDataPerSectorVec",
                                                                              "HoughDataPerSectorVec key"}

Use the hough data to find sectors in the speectrometer traversed by a muon.

Definition at line 51 of file MuonInDetToMuonSystemExtensionAlg.h.

                                                                         {this, "LayerHoughKey", "HoughDataPerSectorVec",
                                                                              "HoughDataPerSectorVec key"};

m_houghMin

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}

private

The hough maxima always contain at least 2 hits.

If a muon track passes through a chamber one expects more than that. Apply a minimum cuts on the hits in the hough maximum to reject background --> needs to be further tuned

Definition at line 109 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"};

m_idHelperSvc

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

private

Definition at line 65 of file MuonInDetToMuonSystemExtensionAlg.h.

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

m_inputCandidate

SG::ReadHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}

private

Definition at line 43 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "InputInDetCandidates", "InDetCandidates"};

m_muonSystemExtensionTool

ToolHandle<Muon::IMuonSystemExtensionTool> MuonInDetToMuonSystemExtensionAlg::m_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}

private

The system extension tool extrapolates the candidate through the spectrometer.

Definition at line 61 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "MuonSystemExtensionTool", "", "Muon system extension tool"};

m_restrictExtension

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_restrictExtension {this, "UseOnlyHitSectors", false}

private

Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded.

Definition at line 106 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "UseOnlyHitSectors", false};

m_sector_mapping

const Muon::MuonSectorMapping MuonInDetToMuonSystemExtensionAlg::m_sector_mapping {}

private

Definition at line 121 of file MuonInDetToMuonSystemExtensionAlg.h.

{};

m_segmentKey

SG::ReadHandleKey<Trk::SegmentCollection> MuonInDetToMuonSystemExtensionAlg::m_segmentKey

private

Initial value:

{this, "MuonSegmentLocation", "TrackMuonSegments",
                                                           "name of muon segment container"}

Let's exploit the segments to get rid of as much tracks as possible.

Definition at line 54 of file MuonInDetToMuonSystemExtensionAlg.h.

                                                      {this, "MuonSegmentLocation", "TrackMuonSegments",
                                                           "name of muon segment container"};

m_segmentQuality

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}

private

Definition at line 111 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "segQuality", 1, "Quality cut on the segment."};

m_segmentSelector

PublicToolHandle<Muon::IMuonSegmentSelectionTool> MuonInDetToMuonSystemExtensionAlg::m_segmentSelector

private

Initial value:

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

Definition at line 57 of file MuonInDetToMuonSystemExtensionAlg.h.

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

m_stauInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_stauInDetCandKey {this, "WriteStauCandidates", ""}

private

Collection of InDet candidates written for MuGirlStau.

Definition at line 48 of file MuonInDetToMuonSystemExtensionAlg.h.

{this, "WriteStauCandidates", ""};

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:

• MuonInDetToMuonSystemExtensionAlg.h
• MuonInDetToMuonSystemExtensionAlg.cxx