MuonCombined::MuonInsideOutRecoTool Class Reference

#include <MuonInsideOutRecoTool.h>

Inheritance diagram for MuonCombined::MuonInsideOutRecoTool:

Collaboration diagram for MuonCombined::MuonInsideOutRecoTool:

Public Member Functions
	MuonInsideOutRecoTool (const std::string &type, const std::string &name, const IInterface *parent)
	Default AlgTool functions.
virtual	~MuonInsideOutRecoTool ()=default
virtual StatusCode	initialize () override
virtual void	extendWithPRDs (const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
	IMuonCombinedInDetExtensionTool interface: extend ID candidate with PRDs for segment-finding.
virtual void	extend (const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
	IMuonCombinedInDetExtensionTool interface: deprecated.
std::pair< std::unique_ptr< const Muon::MuonCandidate >, std::unique_ptr< Trk::Track > >	findBestCandidate (const EventContext &ctx, const xAOD::TrackParticle &indetTrackParticle, const std::vector< Muon::MuonLayerRecoData > &allLayers) const
	find the best candidate for a given set of segments
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	access to tool interface

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	handleCandidate (const InDetCandidate &inDetCandidate, InDetCandidateToTagMap *tagMap, const IMuonCombinedInDetExtensionTool::MuonPrdData &prdData, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segColl, std::vector< std::shared_ptr< const Muon::MuonSegment > > segments, const EventContext &ctx) const
	handle a single candidate
void	addTag (const EventContext &ctx, const InDetCandidate &indetCandidate, InDetCandidateToTagMap *tagMap, const Muon::MuonCandidate &candidate, std::unique_ptr< Trk::Track > &selectedTrack, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments) const
	add muon candidate to indet candidate
bool	getLayerData (const Muon::MuonLayerSurface &surf, Muon::MuonLayerPrepRawData &layerPrepRawData, IMuonCombinedInDetExtensionTool::MuonPrdData prdData) const
	access data in layer
template<class COL>
bool	getLayerDataTech (Muon::MuonStationIndex::TechnologyIndex technology, const Muon::MuonLayerSurface &surf, const Muon::MuonPrepDataContainerT< COL > *input, std::vector< const Muon::MuonPrepDataCollection< COL > * > &output) const
	access data in layer for a given technology
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this, "MuonEDMPrinterTool", ""}
ToolHandle< Muon::IMuonLayerSegmentFinderTool >	m_segmentFinder
ToolHandle< Muon::IMuonLayerSegmentMatchingTool >	m_segmentMatchingTool
ToolHandle< Muon::IMuonLayerAmbiguitySolverTool >	m_ambiguityResolver
ToolHandle< Muon::IMuonCandidateTrackBuilderTool >	m_candidateTrackBuilder
ToolHandle< Rec::ICombinedMuonTrackBuilder >	m_trackFitter
ToolHandle< Trk::ITrackAmbiguityProcessorTool >	m_trackAmbiguityResolver
ToolHandle< Muon::MuonLayerHashProviderTool >	m_layerHashProvider
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
ToolHandle< Muon::IMuonRecoValidationTool >	m_recoValidationTool {this, "MuonRecoValidationTool", ""}
Gaudi::Property< double >	m_idTrackMinPt {this, "IDTrackMinPt", 2500}
Gaudi::Property< bool >	m_ignoreSiAssocated {this, "IgnoreSiAssociatedCandidates", true}
SG::ReadHandleKey< xAOD::VertexContainer >	m_vertexKey {this, "VertexContainer", "PrimaryVertices", "vertex container key"}
SG::ReadHandleKey< Trk::SegmentCollection >	m_inputSegments {this, "InputSegments", "", "Input Segment Collection"}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 45 of file MuonInsideOutRecoTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonInsideOutRecoTool()

MuonCombined::MuonInsideOutRecoTool::MuonInsideOutRecoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Default AlgTool functions.

Definition at line 17 of file MuonInsideOutRecoTool.cxx.

                                                                                                                       :
        AthAlgTool(type, name, parent) {
        declareInterface<IMuonCombinedInDetExtensionTool>(this);
        declareInterface<MuonInsideOutRecoTool>(this);
    }

~MuonInsideOutRecoTool()

virtual MuonCombined::MuonInsideOutRecoTool::~MuonInsideOutRecoTool ( )

virtualdefault

Member Function Documentation

addTag()

void MuonCombined::MuonInsideOutRecoTool::addTag ( const EventContext & ctx, const InDetCandidate & indetCandidate, InDetCandidateToTagMap * tagMap, const Muon::MuonCandidate & candidate, std::unique_ptr< Trk::Track > & selectedTrack, TrackCollection * combTracks, TrackCollection * meTracks, Trk::SegmentCollection * segments ) const

private

add muon candidate to indet candidate

Sort the segments here; note the lifetime of 'copy' is still valid here as it exists inside 'segments'

Sort the CSC segments at the first giving priority to the small sectors

Definition at line 210 of file MuonInsideOutRecoTool.cxx.

                                                                                                                                     {
        const xAOD::TrackParticle& idTrackParticle = indetCandidate.indetTrackParticle();
        Amg::Vector3D origin{0., 0., 0.};
 
        const xAOD::Vertex* matchedVertex = nullptr;
        if (!m_vertexKey.empty()) {
            SG::ReadHandle<xAOD::VertexContainer> vertices{m_vertexKey, ctx};
            if (!vertices.isValid()) {
                ATH_MSG_WARNING("No vertex container with key = " << m_vertexKey.key() << " found");
            } else {
                for (const auto* const vx : *vertices) {
                    for (const auto& tpLink : vx->trackParticleLinks()) {
                        if (*tpLink == &idTrackParticle) {
                            matchedVertex = vx;
                            break;
                        }
                        if (matchedVertex) break;
                    }
                }
            }
        }
        if (matchedVertex) {
            origin = Amg::Vector3D{matchedVertex->x(), matchedVertex->y(), matchedVertex->z()};
            ATH_MSG_DEBUG(" found matched vertex " << origin);
        } else {
            origin = Amg::Vector3D{-idTrackParticle.d0() * std::sin(idTrackParticle.phi()) + idTrackParticle.vx(),
                                   idTrackParticle.d0() * std::cos(idTrackParticle.phi()) + idTrackParticle.vy(),
                                   idTrackParticle.z0() + idTrackParticle.vz()};
            ATH_MSG_DEBUG(" NO matched vertex  take track perigee " << origin);
        }
 
        ATH_MSG_VERBOSE("selectedTrack:");
        if (msgLevel(MSG::VERBOSE)) {
            int tsos = 0;
            for (const Trk::TrackStateOnSurface* it : *selectedTrack->trackStateOnSurfaces()) {
                ++tsos;
                if (it->trackParameters()) {
                    ATH_MSG_VERBOSE("check tsos " << tsos << " r " << it->trackParameters()->position().perp() << " z "
                                                  << it->trackParameters()->position().z() << " p "
                                                  << it->trackParameters()->momentum().mag());
                }
            }
        }
 
        std::vector<const Muon::MuonSegment*> segLinks;
        for (const Muon::MuonLayerIntersection& layer : candidate.layerIntersections) {
            std::unique_ptr<Muon::MuonSegment> copy = std::make_unique<Muon::MuonSegment>(*layer.segment);
            segLinks.push_back(copy.get());
            segments->push_back(std::move(copy));
        }
        //cppcheck-suppress invalidLifetime
        std::sort(segLinks.begin(), segLinks.end(), [this](const Muon::MuonSegment* seg_a, const Muon::MuonSegment* seg_b) -> bool {
            ChIndex ch_a = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*seg_a));
            ChIndex ch_b = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*seg_b));
            StIndex st_a = toStationIndex(ch_a);
            StIndex st_b = toStationIndex(ch_b);
            if (st_a != st_b) return st_a < st_b;
            if (ch_a == ChIndex::CSL || ch_a == ChIndex::CSS || ch_b == ChIndex::CSS || ch_b == ChIndex::CSL)
                return (ch_a == ChIndex::CSL) + 2 * (ch_a == ChIndex::CSS) > (ch_b == ChIndex::CSL) + 2 * (ch_b == ChIndex::CSS);
            return ch_a < ch_b;
        });
 
        if (msgLevel(MSG::DEBUG)) {
            std::stringstream sstr;
            for (const Muon::MuonSegment* muo_seg : segLinks) {
                auto chIdx = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*muo_seg));
                auto thIdx = m_idHelperSvc->technologyIndex(m_edmHelperSvc->chamberId(*muo_seg));
                sstr << chName(chIdx) << "  (" << technologyName(thIdx) << "), ";
            }
            ATH_MSG_DEBUG("Selected segments " << segLinks.size() << " " << sstr.str());
        }
 
        // perform standalone refit
        std::unique_ptr<Trk::Track> standaloneRefit{m_trackFitter->standaloneRefit(ctx, *selectedTrack, origin)};
 
        combTracks->push_back(std::move(selectedTrack));
        ElementLink<TrackCollection> comblink(*combTracks, combTracks->size() - 1);
 
        // create tag and set SA refit
        MuGirlTag* tag = new MuGirlTag(comblink, segLinks);
        if (standaloneRefit) {
            meTracks->push_back(std::move(standaloneRefit));
            ElementLink<TrackCollection> melink(*meTracks, meTracks->size() - 1);
            tag->setUpdatedExtrapolatedTrack(melink);
        }
 
        // add tag to IndetCandidateToTagMap
        tagMap->addEntry(&indetCandidate, tag);
    }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extend()

void MuonCombined::MuonInsideOutRecoTool::extend ( const InDetCandidateCollection & inDetCandidates, InDetCandidateToTagMap * tagMap, TrackCollection * combTracks, TrackCollection * meTracks, Trk::SegmentCollection * segments, const EventContext & ctx ) const

overridevirtual

IMuonCombinedInDetExtensionTool interface: deprecated.

Implements MuonCombined::IMuonCombinedInDetExtensionTool.

Definition at line 41 of file MuonInsideOutRecoTool.cxx.

                                                                      {
        ATH_MSG_WARNING("This version is deprecated, please use extendWithPRDs for MuGirl");
        IMuonCombinedInDetExtensionTool::MuonPrdData prdData;
        extendWithPRDs(inDetCandidates, tagMap, prdData, combTracks, meTracks, segments, ctx);
    }

extendWithPRDs()

void MuonCombined::MuonInsideOutRecoTool::extendWithPRDs ( const InDetCandidateCollection & inDetCandidates, InDetCandidateToTagMap * tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData, TrackCollection * combTracks, TrackCollection * meTracks, Trk::SegmentCollection * segments, const EventContext & ctx ) const

overridevirtual

IMuonCombinedInDetExtensionTool interface: extend ID candidate with PRDs for segment-finding.

Implements MuonCombined::IMuonCombinedInDetExtensionTool.

Definition at line 49 of file MuonInsideOutRecoTool.cxx.

                                                                                                                                         {
        ATH_MSG_DEBUG(" extending " << inDetCandidates.size());
    // vector to store segments
    std::vector<std::shared_ptr<const Muon::MuonSegment>> msegments;
 
    if(!m_inputSegments.empty()){
      SG::ReadHandle<Trk::SegmentCollection> rh_segments(m_inputSegments, ctx);
      const Trk::SegmentCollection *segInColl = rh_segments.ptr();
      for(auto trkSeg : *segInColl){
        auto muonSeg = dynamic_cast<const Muon::MuonSegment*>(trkSeg);
        std::shared_ptr<const Muon::MuonSegment> mseg2 = std::make_shared<const Muon::MuonSegment>(*muonSeg);
        msegments.push_back(mseg2);
      }
    }
    
 
        for (const InDetCandidate* it : inDetCandidates) { handleCandidate(*it, tagMap, prdData, combTracks, meTracks, segments, msegments, ctx); }
    }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

findBestCandidate()

std::pair< std::unique_ptr< const Muon::MuonCandidate >, std::unique_ptr< Trk::Track > > MuonCombined::MuonInsideOutRecoTool::findBestCandidate	(	const EventContext &	ctx,
		const xAOD::TrackParticle &	indetTrackParticle,
		const std::vector< Muon::MuonLayerRecoData > &	allLayers ) const

find the best candidate for a given set of segments

Check if the fit succeeded and whether there are TSOS & a fitQuality

Definition at line 151 of file MuonInsideOutRecoTool.cxx.

                                                                 {
        // resolve ambiguities
        std::vector<Muon::MuonCandidate> resolvedCandidates;
        m_ambiguityResolver->resolveOverlaps(ctx, allLayers, resolvedCandidates);
 
        // fit candidates
        TrackCollection tracks(SG::VIEW_ELEMENTS);
        typedef std::pair<std::unique_ptr<Trk::Track>, std::unique_ptr<const Muon::MuonCandidate>> candidatePair;
        std::vector<candidatePair> trackCandidateLookup;
        for (Muon::MuonCandidate& candidate : resolvedCandidates) {
            std::unique_ptr<Trk::Track> track = m_candidateTrackBuilder->buildCombinedTrack(ctx, *indetTrackParticle.track(), candidate);
            if (!track || !track->isValid() || !track->fitQuality()->numberDoF()) continue;
 
            tracks.push_back(track.get());
            trackCandidateLookup.emplace_back(std::move(track), std::make_unique<Muon::MuonCandidate>(std::move(candidate)));
        }
 
        ATH_MSG_DEBUG("found " << tracks.size() << " combined tracks");
 
        // first handle easy cases of zero or one track
        if (tracks.empty()) return {nullptr, nullptr};
 
        Trk::Track* selectedTrack = nullptr;
        if (tracks.size() == 1) {
            selectedTrack = tracks.front();
        } else {
            // more than 1 track call ambiguity solver and select first track
            std::unique_ptr<const TrackCollection> resolvedTracks(m_trackAmbiguityResolver->process(&tracks));
            if (!resolvedTracks || resolvedTracks->empty()) {
                ATH_MSG_WARNING("Ambiguity resolver returned no tracks. Arbitrarily using the first track of initial collection.");
                selectedTrack = tracks.front();
            } else {
                TrackCollection::iterator it = std::find(tracks.begin(), tracks.end(), resolvedTracks->front());
                if (it != tracks.end()) {
                    selectedTrack = *it;
                } else {
                    ATH_MSG_ERROR("Ambiguity resolver returned an unknown track. Arbitrarily using the first track of initial collection.");
                    selectedTrack = tracks.front();
                }
            }
        }
        // get candidate
        std::vector<candidatePair>::iterator look_itr =
            std::find_if(trackCandidateLookup.begin(), trackCandidateLookup.end(),
                         [selectedTrack](candidatePair& ele) { return ele.first.get() == selectedTrack; });
 
        if (look_itr == trackCandidateLookup.end() || !look_itr->second) {
            ATH_MSG_WARNING("candidate lookup failed, this should not happen");
            return {nullptr, nullptr};
        }
        // generate a track summary for this candidate
        if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*selectedTrack, false); }
 
        return std::make_pair(std::move(look_itr->second), std::move(look_itr->first));
    }

getLayerData()

bool MuonCombined::MuonInsideOutRecoTool::getLayerData ( const Muon::MuonLayerSurface & surf, Muon::MuonLayerPrepRawData & layerPrepRawData, IMuonCombinedInDetExtensionTool::MuonPrdData prdData ) const

private

access data in layer

Definition at line 304 of file MuonInsideOutRecoTool.cxx.

                                                                                                       {
        // get technologies in the given layer
        StIndex stIndex = toStationIndex(surf.regionIndex, surf.layerIndex);
        const std::set<TechnologyIndex>& technologiesInStation = m_idHelperSvc->technologiesInStation(stIndex);
        if (msgLevel(MSG::DEBUG)) {
            std::string techString;
            for (const TechnologyIndex& tech : technologiesInStation)
                techString += " " + technologyName(tech);
            ATH_MSG_DEBUG("getLayerData: sector " << surf.sector << " " << regionName(surf.regionIndex) << " "
                                                  << layerName(surf.layerIndex) << " technologies " << techString);
        }
 
        bool isok{false};
        // loop over technologies and get data
        for (const TechnologyIndex& it : technologiesInStation) {
            // get collections, keep track of failures
            switch(it) {
                using enum TechnologyIndex;
                case TechnologyIndexMax:
                case TechnologyUnknown:
                    break;
                case MDT:
                    isok |= getLayerDataTech<Muon::MdtPrepData>(it, surf, prdData.mdtPrds, layerPrepRawData.mdts);
                    break;
                case RPC:
                    isok |= getLayerDataTech<Muon::RpcPrepData>(it, surf, prdData.rpcPrds, layerPrepRawData.rpcs);
                    break;
                case TGC:
                    isok |= getLayerDataTech<Muon::TgcPrepData>(it, surf, prdData.tgcPrds, layerPrepRawData.tgcs);
                    break;
                case CSC:
                    isok |= getLayerDataTech<Muon::CscPrepData>(it, surf, prdData.cscPrds, layerPrepRawData.cscs);
                    break;
                case STGC:
                    isok |= getLayerDataTech<Muon::sTgcPrepData>(it, surf, prdData.stgcPrds, layerPrepRawData.stgcs);
                    break;
                case MM:
                    isok |= getLayerDataTech<Muon::MMPrepData>(it, surf, prdData.mmPrds, layerPrepRawData.mms);
                    break;
            }
        }
 
        if (msgLvl(MSG::DEBUG)) {
            msg(MSG::DEBUG) << " Got data: sector " << surf.sector << " " << regionName(surf.regionIndex) << " "
                            << layerName(surf.layerIndex);
            if (!layerPrepRawData.mdts.empty()) msg(MSG::DEBUG) << " MDTs " << layerPrepRawData.mdts.size();
            if (!layerPrepRawData.rpcs.empty()) msg(MSG::DEBUG) << " RPCs " << layerPrepRawData.rpcs.size();
            if (!layerPrepRawData.tgcs.empty()) msg(MSG::DEBUG) << " TGCs " << layerPrepRawData.tgcs.size();
            if (!layerPrepRawData.cscs.empty()) msg(MSG::DEBUG) << " CSCs " << layerPrepRawData.cscs.size();
            if (!layerPrepRawData.stgcs.empty()) msg(MSG::DEBUG) << " STGCs " << layerPrepRawData.stgcs.size();
            if (!layerPrepRawData.mms.empty()) msg(MSG::DEBUG) << " MMs " << layerPrepRawData.mms.size();
            msg(MSG::DEBUG) << endmsg;
        }
        return isok;
    }

getLayerDataTech()

template<class COL>

bool MuonCombined::MuonInsideOutRecoTool::getLayerDataTech ( Muon::MuonStationIndex::TechnologyIndex technology, const Muon::MuonLayerSurface & surf, const Muon::MuonPrepDataContainerT< COL > * input, std::vector< const Muon::MuonPrepDataCollection< COL > * > & output ) const

private

access data in layer for a given technology

Definition at line 362 of file MuonInsideOutRecoTool.cxx.

                                                                                                                  {
        if (!input || input->size() == 0) return false;
        // get technologies in the given layer
        unsigned int layHash = sectorLayerHash(surf.regionIndex, surf.layerIndex);
 
        // get hashes
        const Muon::MuonLayerHashProviderTool::HashVec hashes = m_layerHashProvider->getHashes(surf.sector, technology, layHash);
 
        // skip empty inputs
        if (hashes.empty()) return false;
 
        // loop over hashes
        for (Muon::MuonLayerHashProviderTool::HashVec::const_iterator it = hashes.begin(); it != hashes.end(); ++it) {
            // skip if not found
            const auto* colIt = input->indexFindPtr(*it);
            if (!colIt) { continue; }
            ATH_MSG_VERBOSE("  adding " << m_idHelperSvc->toStringChamber(colIt->identify()) << " size " << colIt->size());
            // else add
            output.push_back(colIt);
        }
        return output.size();
    }

handleCandidate()

void MuonCombined::MuonInsideOutRecoTool::handleCandidate ( const InDetCandidate & inDetCandidate, InDetCandidateToTagMap * tagMap, const IMuonCombinedInDetExtensionTool::MuonPrdData & prdData, TrackCollection * combTracks, TrackCollection * meTracks, Trk::SegmentCollection * segColl, std::vector< std::shared_ptr< const Muon::MuonSegment > > segments, const EventContext & ctx ) const

private

handle a single candidate

Definition at line 70 of file MuonInsideOutRecoTool.cxx.

                                                                                                                                                                                                   {
        if (m_ignoreSiAssocated && indetCandidate.isSiliconAssociated()) {
            ATH_MSG_DEBUG(" skip silicon associated track for extension ");
            return;
        }
 
        const xAOD::TrackParticle& indetTrackParticle = indetCandidate.indetTrackParticle();
        if (!indetTrackParticle.track() || indetTrackParticle.pt() < m_idTrackMinPt) return;
 
        // get intersections which precision layers in the muon system
        const Muon::MuonSystemExtension* muonSystemExtension = indetCandidate.getExtension();
        if (!muonSystemExtension) {
            ATH_MSG_VERBOSE("No MuonSystemExtension, aborting ");
            return;
        }
        // fill validation content
        if (!m_recoValidationTool.empty()) m_recoValidationTool->addTrackParticle(indetTrackParticle, *muonSystemExtension);
 
        // loop over intersections, get segments
        std::vector<Muon::MuonLayerRecoData> allLayers;
 
        const std::vector<Muon::MuonSystemExtension::Intersection>& layerIntersections = muonSystemExtension->layerIntersections();
        ATH_MSG_DEBUG(" ID track: pt " << indetTrackParticle.pt() << " eta " << indetTrackParticle.eta() << " phi "
                                       << indetTrackParticle.phi() << " layers " << layerIntersections.size());
 
 
    
 
    for (const Muon::MuonSystemExtension::Intersection& layer_intersect : layerIntersections) {
 
            // find segments for intersection
            Muon::MuonLayerPrepRawData layerPrepRawData;
            if (!getLayerData(layer_intersect.layerSurface, layerPrepRawData, prdData)) {
                ATH_MSG_VERBOSE("Failed to get layer data");
                continue;
            }
        
            if(!m_segmentFinder.empty()){
          segments.clear();
          m_segmentFinder->find(ctx, layer_intersect, layerPrepRawData, segments);
        }
            if (segments.empty()) continue;
 
            // fill validation content
            if (!m_recoValidationTool.empty()) {
                for (const std::shared_ptr<const Muon::MuonSegment>& seg : segments) m_recoValidationTool->add(layer_intersect, *seg, 0);
            }
 
            // match segments to intersection
            std::vector<std::shared_ptr<const Muon::MuonSegment>> selectedSegments;
            m_segmentMatchingTool->select(ctx, layer_intersect, segments, selectedSegments);
            if (selectedSegments.empty()) continue;
 
            // fill validation content
            if (!m_recoValidationTool.empty()) {
                for (const auto& seg : selectedSegments) m_recoValidationTool->add(layer_intersect, *seg, 1);
            }
 
            // add to total list
            allLayers.emplace_back(layer_intersect, std::move(selectedSegments));
        }
 
        if (msgLvl(MSG::DEBUG)) {
            msg(MSG::DEBUG) << " Layers with segments " << allLayers.size();
            for (auto& layer : allLayers) {
                for (auto& seg : layer.segments) { msg(MSG::DEBUG) << std::endl << m_printer->print(*seg); }
            }
            msg(MSG::DEBUG) << endmsg;
        }
 
        // find best candidate and exit if none found
        std::pair<std::unique_ptr<const Muon::MuonCandidate>, std::unique_ptr<Trk::Track>> bestCandidate =
            findBestCandidate(ctx, indetTrackParticle, allLayers);
        if (!bestCandidate.first) { return; }
 
        // add candidate to indet candidate
        addTag(ctx, indetCandidate, tagMap, *bestCandidate.first, bestCandidate.second, combTracks, meTracks, segColl);
    }

initialize()

StatusCode MuonCombined::MuonInsideOutRecoTool::initialize ( )

overridevirtual

Definition at line 23 of file MuonInsideOutRecoTool.cxx.

                                                 {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_segmentFinder.retrieve(DisableTool(m_segmentFinder.empty())));
        ATH_CHECK(m_segmentMatchingTool.retrieve());
        ATH_CHECK(m_ambiguityResolver.retrieve());
        ATH_CHECK(m_candidateTrackBuilder.retrieve());
        ATH_CHECK(m_trackFitter.retrieve());
        ATH_CHECK(m_trackAmbiguityResolver.retrieve());
        // trigger does not use primary vertex
        ATH_CHECK(m_vertexKey.initialize(!m_vertexKey.empty()));
        ATH_CHECK(m_trackSummaryTool.retrieve());
        ATH_CHECK(m_recoValidationTool.retrieve(DisableTool{m_recoValidationTool.empty()}));
    ATH_CHECK(m_inputSegments.initialize(!m_inputSegments.empty()));
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & MuonCombined::MuonInsideOutRecoTool::interfaceID ( )

inlinestatic

access to tool interface

Definition at line 53 of file MuonInsideOutRecoTool.h.

{ return IID_MuonInsideOutRecoTool; }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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_ambiguityResolver

ToolHandle<Muon::IMuonLayerAmbiguitySolverTool> MuonCombined::MuonInsideOutRecoTool::m_ambiguityResolver

private

Initial value:

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

Definition at line 98 of file MuonInsideOutRecoTool.h.

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

m_candidateTrackBuilder

ToolHandle<Muon::IMuonCandidateTrackBuilderTool> MuonCombined::MuonInsideOutRecoTool::m_candidateTrackBuilder

private

Initial value:

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

Definition at line 100 of file MuonInsideOutRecoTool.h.

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

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonCombined::MuonInsideOutRecoTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 91 of file MuonInsideOutRecoTool.h.

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

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idHelperSvc

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

private

Definition at line 90 of file MuonInsideOutRecoTool.h.

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

m_idTrackMinPt

Gaudi::Property<double> MuonCombined::MuonInsideOutRecoTool::m_idTrackMinPt {this, "IDTrackMinPt", 2500}

private

Definition at line 111 of file MuonInsideOutRecoTool.h.

{this, "IDTrackMinPt", 2500};

m_ignoreSiAssocated

Gaudi::Property<bool> MuonCombined::MuonInsideOutRecoTool::m_ignoreSiAssocated {this, "IgnoreSiAssociatedCandidates", true}

private

Definition at line 112 of file MuonInsideOutRecoTool.h.

{this, "IgnoreSiAssociatedCandidates", true};

m_inputSegments

SG::ReadHandleKey<Trk::SegmentCollection> MuonCombined::MuonInsideOutRecoTool::m_inputSegments {this, "InputSegments", "", "Input Segment Collection"}

private

Definition at line 117 of file MuonInsideOutRecoTool.h.

{this, "InputSegments", "", "Input Segment Collection"};

m_layerHashProvider

ToolHandle<Muon::MuonLayerHashProviderTool> MuonCombined::MuonInsideOutRecoTool::m_layerHashProvider

private

Initial value:

{this, "MuonLayerHashProviderTool",
                                                                        "Muon::MuonLayerHashProviderTool"}

Definition at line 106 of file MuonInsideOutRecoTool.h.

                                                                     {this, "MuonLayerHashProviderTool",
                                                                        "Muon::MuonLayerHashProviderTool"};

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuonCombined::MuonInsideOutRecoTool::m_printer {this, "MuonEDMPrinterTool", ""}

private

Definition at line 93 of file MuonInsideOutRecoTool.h.

{this, "MuonEDMPrinterTool", ""};

m_recoValidationTool

ToolHandle<Muon::IMuonRecoValidationTool> MuonCombined::MuonInsideOutRecoTool::m_recoValidationTool {this, "MuonRecoValidationTool", ""}

private

Definition at line 109 of file MuonInsideOutRecoTool.h.

{this, "MuonRecoValidationTool", ""};

m_segmentFinder

ToolHandle<Muon::IMuonLayerSegmentFinderTool> MuonCombined::MuonInsideOutRecoTool::m_segmentFinder

private

Initial value:

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

Definition at line 94 of file MuonInsideOutRecoTool.h.

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

m_segmentMatchingTool

ToolHandle<Muon::IMuonLayerSegmentMatchingTool> MuonCombined::MuonInsideOutRecoTool::m_segmentMatchingTool

private

Initial value:

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

Definition at line 96 of file MuonInsideOutRecoTool.h.

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

m_trackAmbiguityResolver

ToolHandle<Trk::ITrackAmbiguityProcessorTool> MuonCombined::MuonInsideOutRecoTool::m_trackAmbiguityResolver

private

Initial value:

{this, "TrackAmbiguityProcessor",
                                                                               "Trk::TrackSelectionProcessorTool/MuonAmbiProcessor"}

Definition at line 104 of file MuonInsideOutRecoTool.h.

                                                                            {this, "TrackAmbiguityProcessor",
                                                                               "Trk::TrackSelectionProcessorTool/MuonAmbiProcessor"};

m_trackFitter

ToolHandle<Rec::ICombinedMuonTrackBuilder> MuonCombined::MuonInsideOutRecoTool::m_trackFitter

private

Initial value:

{this, "MuonTrackBuilder",
                                                                 "Rec::CombinedMuonTrackBuilder/CombinedMuonTrackBuilder"}

Definition at line 102 of file MuonInsideOutRecoTool.h.

                                                              {this, "MuonTrackBuilder",
                                                                 "Rec::CombinedMuonTrackBuilder/CombinedMuonTrackBuilder"};

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> MuonCombined::MuonInsideOutRecoTool::m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}

private

Definition at line 108 of file MuonInsideOutRecoTool.h.

{this, "TrackSummaryTool", "MuonTrackSummaryTool"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexKey

SG::ReadHandleKey<xAOD::VertexContainer> MuonCombined::MuonInsideOutRecoTool::m_vertexKey {this, "VertexContainer", "PrimaryVertices", "vertex container key"}

private

Definition at line 115 of file MuonInsideOutRecoTool.h.

{this, "VertexContainer", "PrimaryVertices", "vertex container key"};

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MuonInsideOutRecoTool.h
• MuonInsideOutRecoTool.cxx