Muon::MuonTrackSteering Class Reference

Implementation of an IMuonTrackFinder. More...

#include <MuonTrackSteering.h>

Inheritance diagram for Muon::MuonTrackSteering:

Collaboration diagram for Muon::MuonTrackSteering:

Classes
struct	GarbageContainer

Public Types
typedef std::vector< MuPatTrack * >	TrkVec
typedef std::vector< Trk::Track * >	TrkCollVec
typedef std::vector< MuPatSegment * >	SegCol
typedef std::vector< MuPatSegment * >::iterator	SegColIt
typedef std::vector< SegCol >	SegColVec
typedef SegColVec::iterator	SegColVecIt
typedef SegColVec::const_iterator	SegColVecCit
typedef std::set< MuonStationIndex::ChIndex >	ChSet
typedef ChSet::iterator	ChIt
typedef ChSet::const_iterator	ChCit
typedef std::set< MuonStationIndex::StIndex >	StSet
typedef StSet::iterator	StIt
typedef StSet::const_iterator	StCit

Public Member Functions
	MuonTrackSteering (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor More...
virtual	~MuonTrackSteering ()=default
	destructor More...
virtual StatusCode	initialize () override
	initialize method, method taken from bass-class AlgTool More...
std::unique_ptr< TrackCollection >	find (const EventContext &ctx, const MuonSegmentCollection &coll) const override
	find tracks starting from a MuonSegmentCollection More...
virtual std::unique_ptr< TrackCollection >	find (const EventContext &ctx, const std::vector< const MuonSegment * > &segments) const =0
	interface for tools to find track in the muon system starting from a vector of segments More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< TrackCollection >	selectTracks (std::vector< std::unique_ptr< MuPatTrack >> &candidates, bool takeOwnership=true) const
std::unique_ptr< TrackCollection >	findTracks (const EventContext &ctx, SegColVec &chamberSegments, SegColVec &stationSegments) const
	actual find method More...
bool	extractSegments (const EventContext &ctx, const MuonSegmentCollection &coll, SegColVec &chamberSegments, SegColVec &stationSegments, ChSet &chambersWithSegments, StSet &stationsWithSegments, GarbageContainer &trash_bin) const
StatusCode	decodeStrategyVector (const std::vector< std::string > &strategy)
std::unique_ptr< const MuonTrackSteeringStrategy >	decodeStrategy (const std::string &strategy) const
std::vector< std::unique_ptr< MuPatTrack > >	extendWithLayer (const EventContext &ctx, MuPatTrack &candidate, const SegColVec &segcol, unsigned int nextlayer, const unsigned int endlayer, int cutLevel=0) const
std::vector< std::unique_ptr< MuPatTrack > >	findTrackFromSeed (const EventContext &ctx, MuPatSegment &seedSeg, const MuonTrackSteeringStrategy &strat, const unsigned int layer, const SegColVec &segs) const
	Find tracks starting from a good segment. More...
void	refineTracks (const EventContext &ctx, std::vector< std::unique_ptr< MuPatTrack >> &candidates) const
void	solveAmbiguities (std::vector< std::unique_ptr< MuPatTrack >> &tracks, const MuonTrackSteeringStrategy *strat=nullptr) const
	Resolve ambiguities among tracks for a single strategy This allows a strategy-specific ambiguity solving (with some options per strategy) More...
void	combineOverlapSegments (const EventContext &ctx, std::vector< MuPatSegment * > &ch1, std::vector< MuPatSegment * > &ch2, SegColVec &stationSegments, StSet &stationsWithSegments, GarbageContainer &trash_bin) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static bool	decodeList (const std::string &input, std::vector< std::string > &list)

Private Attributes
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
PublicToolHandle< MuonEDMPrinterTool >	m_printer {this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ToolHandle< MuPatCandidateTool >	m_candidateTool {this, "MuPatCandidateTool", "Muon::MuPatCandidateTool/MuPatCandidateTool"}
ToolHandle< IMuonTrackBuilder >	m_trackBTool {this, "TrackBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}
ToolHandle< Trk::ITrackAmbiguityProcessorTool >	m_ambiTool
ToolHandle< MooTrackBuilder >	m_mooBTool {this, "MooBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}
ToolHandle< MooCandidateMatchingTool >	m_candidateMatchingTool
ToolHandle< IMuonTrackRefiner >	m_trackRefineTool {this, "TrackRefinementTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}
ToolHandle< IMuonSegmentFittingTool >	m_segmentFitter
ToolHandle< Muon::MuonTrackSelectorTool >	m_trackSelector
ToolHandle< IMuonHoleRecoveryTool >	m_muonHoleRecoverTool
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
std::vector< std::unique_ptr< const MuonTrackSteeringStrategy > >	m_strategies
std::vector< std::string >	m_stringStrategies
std::array< int, 3 >	m_segQCut {}
	Required segment quality for seed, 2nd, and other segments. More...
bool	m_outputSingleStationTracks
bool	m_combinedSLOverlaps
bool	m_doSummary
bool	m_useTightMatching
bool	m_onlyMDTSeeding
int	m_segThreshold
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Implementation of an IMuonTrackFinder.

For more details look at the mainpage of this package.

Definition at line 51 of file MuonTrackSteering.h.

Member Typedef Documentation

ChCit

typedef ChSet::const_iterator Muon::MuonTrackSteering::ChCit

Definition at line 63 of file MuonTrackSteering.h.

ChIt

typedef ChSet::iterator Muon::MuonTrackSteering::ChIt

Definition at line 62 of file MuonTrackSteering.h.

ChSet

typedef std::set<MuonStationIndex::ChIndex> Muon::MuonTrackSteering::ChSet

Definition at line 61 of file MuonTrackSteering.h.

SegCol

typedef std::vector<MuPatSegment*> Muon::MuonTrackSteering::SegCol

Definition at line 55 of file MuonTrackSteering.h.

SegColIt

typedef std::vector<MuPatSegment*>::iterator Muon::MuonTrackSteering::SegColIt

Definition at line 56 of file MuonTrackSteering.h.

SegColVec

typedef std::vector<SegCol> Muon::MuonTrackSteering::SegColVec

Definition at line 57 of file MuonTrackSteering.h.

SegColVecCit

typedef SegColVec::const_iterator Muon::MuonTrackSteering::SegColVecCit

Definition at line 59 of file MuonTrackSteering.h.

SegColVecIt

typedef SegColVec::iterator Muon::MuonTrackSteering::SegColVecIt

Definition at line 58 of file MuonTrackSteering.h.

StCit

typedef StSet::const_iterator Muon::MuonTrackSteering::StCit

Definition at line 67 of file MuonTrackSteering.h.

StIt

typedef StSet::iterator Muon::MuonTrackSteering::StIt

Definition at line 66 of file MuonTrackSteering.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

StSet

typedef std::set<MuonStationIndex::StIndex> Muon::MuonTrackSteering::StSet

Definition at line 65 of file MuonTrackSteering.h.

TrkCollVec

typedef std::vector<Trk::Track*> Muon::MuonTrackSteering::TrkCollVec

Definition at line 54 of file MuonTrackSteering.h.

TrkVec

typedef std::vector<MuPatTrack*> Muon::MuonTrackSteering::TrkVec

Definition at line 53 of file MuonTrackSteering.h.

Constructor & Destructor Documentation

MuonTrackSteering()

Muon::MuonTrackSteering::MuonTrackSteering	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

default AlgTool constructor

Definition at line 50 of file MuonTrackSteering.cxx.

                                                                                                    :
        AthAlgTool(t, n, p), m_combinedSLOverlaps(false) {
        declareInterface<IMuonTrackFinder>(this);
 
        declareProperty("StrategyList", m_stringStrategies, "List of strategies to be used by the track steering");
        declareProperty("SegSeedQCut", m_segQCut[0] = -2, "Required quality for segments to be a seed");
        declareProperty("Seg2ndQCut", m_segQCut[1] = -2, "Required quality for segments to be the second on a track");
        declareProperty("SegOtherQCut", m_segQCut[2] = -2, "Required quality for segments to be added to a track");
        declareProperty("OutputSingleStationTracks", m_outputSingleStationTracks = false);
        declareProperty("DoSummary", m_doSummary = false);
        declareProperty("UseTightSegmentMatching", m_useTightMatching = true);
        declareProperty("SegmentThreshold", m_segThreshold = 8);
        declareProperty("OnlyMdtSeeding", m_onlyMDTSeeding = true);
    }

~MuonTrackSteering()

virtual Muon::MuonTrackSteering::~MuonTrackSteering ( )

virtualdefault

destructor

Member Function Documentation

combineOverlapSegments()

void Muon::MuonTrackSteering::combineOverlapSegments ( const EventContext &  ctx, std::vector< MuPatSegment * > &  ch1, std::vector< MuPatSegment * > &  ch2, SegColVec &  stationSegments, StSet &  stationsWithSegments, GarbageContainer &  trash_bin  ) const

private

try to find small/large overlaps, insert segment into stationVec

Start with -1 as the first operation in the loop over the second set of chambers is the counter incrementation

Actually this should be always 1. What should it conceptionally reject? The angle between the combined segment and the segment from the first collection?

Definition at line 161 of file MuonTrackSteering.cxx.

                                                                                      {
        // if both empty there is nothing to be done
        if (ch1.empty() && ch2.empty()) return;
 
        // get station index from the first segment in the first non empty vector
        MuonStationIndex::StIndex stIndex = !ch1.empty() ? ch1.front()->stIndex : ch2.front()->stIndex;
 
        SegCol& stationVec = stationSegments[stIndex];
 
        // vector to flag entries in the second station that were matched
        std::vector<bool> wasMatched2(ch2.size(), false);
 
        // loop over all possible combinations
        for (MuPatSegment* sit1 : ch1) {
            // do not combine poor quality segments
            int qualityLevel1 = ch1.size() > 5 ? 1 : 2;
            if (sit1->quality < qualityLevel1) {
                ATH_MSG_VERBOSE("resolveSLOverlaps::bad segment1 q: " << sit1->quality << " cut " << qualityLevel1 << std::endl
                                                                      << m_printer->print(*sit1->segment));
                stationVec.push_back(sit1);
                continue;
            }
 
            bool wasMatched1 = false;
 
            // apply looser cuts as we perform matching
            int qualityLevel2 = ch2.size() > 5 ? 1 : 2;
            int idx_ch2 = -1;
            for (MuPatSegment* sit2 : ch2) {
                ++idx_ch2;
                // do not combine poor quality segments AND require at least one of the segments to have a quality beter than 1
                if (sit2->quality < qualityLevel2) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps::bad segment2:  q " << sit2->quality << " cut " << qualityLevel2 << std::endl
                                                                           << m_printer->print(*sit2->segment));
                    continue;
                }
                if (sit1->quality < 2 && sit2->quality < 2) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps:: combination of insufficient quality " << std::endl
                                                                                               << " q1 " << sit1->quality << " q2 "
                                                                                               << sit1->quality);
                    continue;
                }
 
                ATH_MSG_VERBOSE(" combining entries: " << std::endl
                                                       << m_printer->print(*sit1->segment) << std::endl
                                                       << m_printer->print(*sit2->segment));
 
                if (!m_candidateMatchingTool->match(ctx, *sit1, *sit2, false)) {
                    ATH_MSG_VERBOSE(" overlap combination rejected based on matching" << std::endl << m_printer->print(*sit2->segment));
                    continue;
                }
 
                // create MuonSegment
                static const Muon::IMuonSegmentTrackBuilder::PrepVec emptyPhiHits{};
                std::unique_ptr<MuonSegment> newseg{m_mooBTool->combineToSegment(ctx, *sit1, *sit2, emptyPhiHits)};
                if (!newseg) {
                    ATH_MSG_DEBUG(" Combination of segments failed ");
                    continue;
                }
                const Trk::FitQuality* fq = newseg->fitQuality();
                if (!fq || fq->numberDoF() == 0) {
                    ATH_MSG_WARNING(" no fit quality, dropping segment ");
                    continue;
                }
                if (fq->chiSquared() / fq->numberDoF() > 2.5) {
                    ATH_MSG_DEBUG("bad fit quality, dropping segment " << fq->chiSquared() / fq->numberDoF());
                    continue;
                }
                std::unique_ptr<MuPatSegment> segInfo = m_candidateTool->createSegInfo(ctx, *newseg);
                // check whether segment of good quality AND that its quality is equal or better than the input segments
                if (segInfo->quality < 2 || (segInfo->quality < sit1->quality || segInfo->quality < sit2->quality)) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps::bad segment " << std::endl << m_printer->print(*segInfo->segment));
                    continue;
                }                
                int shared_eta = 0, shared_phi = 0;  // check for hits shared between segments
 
                const MuPatSegment* const_sit1 = sit1;
                const MuPatSegment* const_sit2 = sit2;
                for (const MuPatHitPtr& hit_ch1 : const_sit1->hitList()) {
                    for (const MuPatHitPtr& hit_ch2 : const_sit2->hitList()) {
                        if (hit_ch1->info().id == hit_ch2->info().id) {
                            if (hit_ch1->info().measuresPhi)
                                shared_phi++;
                            else
                                shared_eta++;
                        }
                    }
                }
 
                if (sit1->etaHits().size() + sit2->etaHits().size() - shared_eta - segInfo->etaHits().size() > 1) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps::more than one eta measurement removed, dropping track "
                                    << std::endl
                                    << m_printer->print(*segInfo->segment));
                    continue;
                }
 
                int phiHitDiff = sit1->phiHits().size() + sit2->phiHits().size() - shared_phi - segInfo->phiHits().size();
                if (phiHitDiff > 1 || (sit1->phiHits().size() + sit2->phiHits().size() > 0 && segInfo->phiHits().empty())) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps::more than one phi measurement removed, dropping track "
                                    << std::endl
                                    << m_printer->print(*segInfo->segment));
                    continue;
                }
                double cosPointingAngle = (newseg->globalPosition().x() * newseg->globalDirection().x() +
                                           newseg->globalPosition().y() * newseg->globalDirection().y()) /
                                          (newseg->globalPosition().perp() * newseg->globalDirection().perp());
                if (cosPointingAngle < 0.995) {
                    ATH_MSG_VERBOSE("resolveSLOverlaps: rejected due to too large pointing angle " << std::endl
                                                                                                   << m_printer->print(*segInfo->segment));
                    continue;
                }
                ATH_MSG_VERBOSE("created SL overlap segment: cos pointing " << cosPointingAngle << std::endl
                                                                            << m_printer->print(*segInfo->segment));
 
                // flag segments as matched
                wasMatched1 = true;
                wasMatched2[idx_ch2] = true;
 
                // add segment
                stationVec.push_back(segInfo.get());
                trash_bin.push_back(std::move(newseg));
                trash_bin.push_back(std::move(segInfo));
                
            }
 
            // if entry was not associated with entry in other station add it to entries
            if (!wasMatched1) { stationVec.push_back(sit1); }
        }
 
        // loop over entries in second station and add unassociated entries to candidate entries
        for (unsigned int i = 0; i < wasMatched2.size(); ++i) {
            if (!wasMatched2[i]) { stationVec.push_back(ch2[i]); }
        }
 
        // add station to list of stations with segments
        if (!stationVec.empty()) { stationsWithSegments.insert(stIndex); }
 
        // sort segment according to their quality
        std::stable_sort(stationVec.begin(), stationVec.end(), SortSegInfoByQuality());
    }

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

decodeList()

bool Muon::MuonTrackSteering::decodeList ( const std::string &  input, std::vector< std::string > &  list  )

staticprivate

Definition at line 812 of file MuonTrackSteering.cxx.

                                                                                         {
        bool result = true;
        std::string::size_type begIdx = 0;
        std::string::size_type endIdx = 0;
        do {
            endIdx = input.find(',', begIdx);
            std::string::size_type lstIdx = endIdx;
            if (std::string::npos == endIdx) { lstIdx = input.length(); }
            std::string item = input.substr(begIdx, lstIdx - begIdx);
            list.push_back(item);
            begIdx = lstIdx + 1;
        } while (std::string::npos != endIdx);
        return result;
    }

decodeStrategy()

std::unique_ptr< const MuonTrackSteeringStrategy > Muon::MuonTrackSteering::decodeStrategy ( const std::string &  strategy ) const

private

Definition at line 719 of file MuonTrackSteering.cxx.

                                                                                                                    {
        const std::string delims(" \t[],;");
 
        // The strategy name
        std::string name;
 
        // The strategy options (which should be a vector of enums, but I'll use strings now to check that I'm
        // decoding the stragegy correctly)
        std::vector<std::string> options;
 
        // The strategy sequence (which should be a vector of vector of station enumbs, but again I'll use
        // strings instead of enums to test that I've got the decoding correct)
        typedef std::vector<std::string> ChamberGroup;
        std::vector<ChamberGroup> sequence;
        std::string seqStr;
 
        bool success = false;
        std::unique_ptr<const MuonTrackSteeringStrategy> result;
 
        std::string::size_type length = strategy.length();
 
        // Extract the strategy name and options
        std::string::size_type begIdx, endIdx;
        begIdx = strategy.find_first_not_of(delims);
        if (std::string::npos != begIdx) {
            endIdx = strategy.find(':', begIdx);
            if (std::string::npos != endIdx) {
                seqStr = strategy.substr(endIdx + 1, length - endIdx - 1);
                std::string nameopt = strategy.substr(begIdx, endIdx - begIdx);
                std::string::size_type bi = nameopt.find('[');
                if (std::string::npos != bi) {
                    name = nameopt.substr(0, bi);
 
                    // Decode options
                    std::string::size_type ei = nameopt.find(']', bi);
                    if (std::string::npos == ei) { ei = nameopt.length(); }
                    std::string inputOpt = nameopt.substr(bi + 1, ei - bi - 1);
                    success = decodeList(inputOpt, options);
                } else {
                    name = nameopt;
                }
            }
        }
        if (msgLvl(MSG::DEBUG)) {
            ATH_MSG_DEBUG("From strat: " << strategy << " with success " << success << " end " << endIdx << " beg " << begIdx
                                         << " Name: " << name << " options: ");
            for (std::vector<std::string>::iterator oit = options.begin(); oit != options.end(); ++oit)
                msg(MSG::DEBUG) << "  " << *oit << endmsg;
        }
        // Name and options successfully decoded, now decode the sequence and groups
        if (success) {
            begIdx = endIdx + 1;
            do {
                endIdx = strategy.find(';', begIdx);
                std::string::size_type lstIdx = endIdx;
                if (std::string::npos == endIdx) { lstIdx = strategy.length(); }
                std::string grpString = strategy.substr(begIdx, lstIdx - begIdx);
                ChamberGroup group;
                success = success && decodeList(grpString, group);
                sequence.push_back(group);
                begIdx = lstIdx + 1;
            } while (std::string::npos != endIdx && success);
        }
 
        if (success) {
            std::vector<std::vector<MuonStationIndex::ChIndex> > path;
            for (unsigned int i = 0; i < sequence.size(); ++i) {
                std::vector<MuonStationIndex::ChIndex> idxGrp;
                for (unsigned int j = 0; j < sequence[i].size(); ++j) {
                    MuonStationIndex::ChIndex idx = MuonStationIndex::chIndex(sequence[i][j]);
                    if (MuonStationIndex::ChUnknown == idx) {
                        if (sequence[i][j] != "all" && sequence[i][j] != "ALL" && sequence[i][j] != "All") {
                            // Complain
                            ATH_MSG_WARNING("I am complaining: Bad station index.");
                        } else {  // asked for all chambers
                            idxGrp.clear();
                            for (int all = MuonStationIndex::BIS; all != MuonStationIndex::ChIndexMax; ++all)
                                idxGrp.push_back(MuonStationIndex::ChIndex(all));
                        }
                    } else {
                        idxGrp.push_back(idx);
                    }
                }
                path.push_back(idxGrp);
            }
            result = std::make_unique<MuonTrackSteeringStrategy>(name, options, path);
        }
 
        return result;
    }

decodeStrategyVector()

StatusCode Muon::MuonTrackSteering::decodeStrategyVector ( const std::vector< std::string > &  strategy )

private

Definition at line 702 of file MuonTrackSteering.cxx.

                                                                                           {
        for (unsigned int i = 0; i < strategy.size(); ++i) {
            std::unique_ptr<const MuonTrackSteeringStrategy> holder = decodeStrategy(strategy[i]);
            if (!holder) {
                // complain
                ATH_MSG_DEBUG("failed to decode strategy");
            } else {
                // flag whether segments should be combined
                if (holder->option(MuonTrackSteeringStrategy::CombineSegInStation)) m_combinedSLOverlaps = true;
                m_strategies.emplace_back(std::move(holder));
            }
        }
        return StatusCode::SUCCESS;
    }

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() [1/2]

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

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extendWithLayer()

std::vector< std::unique_ptr< MuPatTrack > > Muon::MuonTrackSteering::extendWithLayer ( const EventContext &  ctx, MuPatTrack &  candidate, const SegColVec &  segcol, unsigned int  nextlayer, const unsigned int  endlayer, int  cutLevel = 0  ) const

private

Definition at line 617 of file MuonTrackSteering.cxx.

                                                                                                     {
        std::vector<std::unique_ptr<MuPatTrack> > result;
        if (nextlayer < endlayer) {
            for (; nextlayer != endlayer; nextlayer++) {
                if (segs[nextlayer].empty()) continue;
 
                std::vector<std::unique_ptr<MuPatTrack> > nextTracks = m_trackBTool->find(ctx, candidate, segs[nextlayer]);
                if (!nextTracks.empty()) {
                    for (std::unique_ptr<MuPatTrack>& cit : nextTracks) {
                        std::vector<std::unique_ptr<MuPatTrack> > nextTracks2 =
                            extendWithLayer(ctx, *cit, segs, nextlayer + 1, endlayer, cutLevel);
                        if (!nextTracks2.empty()) {
                            result.insert(result.end(), std::make_move_iterator(nextTracks2.begin()),
                                          std::make_move_iterator(nextTracks2.end()));
                        } else {
                            result.push_back(std::move(cit));
                        }
                    }
                }
            }
        }
 
        return result;
    }

extractSegments()

bool Muon::MuonTrackSteering::extractSegments ( const EventContext &  ctx, const MuonSegmentCollection &  coll, SegColVec &  chamberSegments, SegColVec &  stationSegments, ChSet &  chambersWithSegments, StSet &  stationsWithSegments, GarbageContainer &  trash_bin  ) const

private

Definition at line 103 of file MuonTrackSteering.cxx.

                                                                                                                                         {
        if (coll.empty()) return false;
 
        ATH_MSG_DEBUG("New collection " << coll.size());
 
        // Sort the input collection by chamber & station IDs
        for (const MuonSegment* segment : coll) {
            ATH_MSG_DEBUG("Adding segment ");
            std::unique_ptr<MuPatSegment> aSeg = m_candidateTool->createSegInfo(ctx, *segment);
            ATH_MSG_DEBUG(" -> MuPatSegment " << m_candidateTool->print(*aSeg));
 
            MuonStationIndex::ChIndex chIndex = aSeg->chIndex;
            MuonStationIndex::StIndex stIndex = aSeg->stIndex;
            if (chIndex < 0 || stIndex < 0) {
                ATH_MSG_WARNING("Chamber or station index invalid:" << m_candidateTool->print(*aSeg));
                continue;
            }
            chambersWithSegments.insert(chIndex);
            stationsWithSegments.insert(stIndex);
 
            std::vector<MuPatSegment*>& segments = chamberSegments[chIndex];
            segments.push_back(aSeg.get());
            if (!m_combinedSLOverlaps) {
                std::vector<MuPatSegment*>& segments2 = stationSegments[stIndex];
                segments2.push_back(aSeg.get());
            }
            trash_bin.push_back(std::move(aSeg));
        }
 
        if (m_combinedSLOverlaps) {
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::BIS], chamberSegments[MuonStationIndex::BIL], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::BMS], chamberSegments[MuonStationIndex::BML], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::BOS], chamberSegments[MuonStationIndex::BOL], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::EIS], chamberSegments[MuonStationIndex::EIL], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::EMS], chamberSegments[MuonStationIndex::EML], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::EOS], chamberSegments[MuonStationIndex::EOL], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::EES], chamberSegments[MuonStationIndex::EEL], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[MuonStationIndex::CSS], chamberSegments[MuonStationIndex::CSL], stationSegments,
                                   stationsWithSegments, trash_bin);
            std::vector<MuPatSegment*>& segments = chamberSegments[MuonStationIndex::BEE];
            if (!segments.empty()) {
                chambersWithSegments.insert(MuonStationIndex::BEE);
                stationsWithSegments.insert(MuonStationIndex::BE);
                std::vector<MuPatSegment*>& segs = stationSegments[MuonStationIndex::BE];
                segs.insert(segs.end(), segments.begin(), segments.end());
            }
        }
        return true;
    }

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

find() [1/2]

std::unique_ptr< TrackCollection > Muon::MuonTrackSteering::find ( const EventContext &  ctx, const MuonSegmentCollection &  coll  ) const

override

find tracks starting from a MuonSegmentCollection

Parameters

coll	a reference to a MuonSegmentCollection

Returns

a pointer to a vector of tracks, the ownership of the tracks is passed to the client calling the tool.

Definition at line 85 of file MuonTrackSteering.cxx.

                                                                                                                           {
        GarbageContainer trash_bin{};
        trash_bin.reserve(150);
 
        std::unique_ptr<TrackCollection> result = std::make_unique<TrackCollection>();
 
        SegColVec chamberSegments(MuonStationIndex::ChIndexMax);  // <! Segments sorted per Chamber
        SegColVec stationSegments(MuonStationIndex::StIndexMax);  // <! Segments sorted per station
        ChSet chambersWithSegments;
        StSet stationsWithSegments;
        // Extract segments into work arrays
        if (extractSegments(ctx, coll, chamberSegments, stationSegments, chambersWithSegments, stationsWithSegments, trash_bin)) {
            // Perform the actual track finding
            result = findTracks(ctx, chamberSegments, stationSegments);
        }
        return result;
    }

find() [2/2]

virtual std::unique_ptr<TrackCollection> Muon::IMuonTrackFinder::find ( const EventContext &  ctx, const std::vector< const MuonSegment * > &  segments  ) const

pure virtualinherited

interface for tools to find track in the muon system starting from a vector of segments

Parameters

segments

a vector of input segments

Returns

a pointer to a vector of Trk::Track objects, zero if no tracks are found. The ownership of the tracks is passed to the client calling the tool.

findTrackFromSeed()

std::vector< std::unique_ptr< MuPatTrack > > Muon::MuonTrackSteering::findTrackFromSeed ( const EventContext &  ctx, MuPatSegment &  seedSeg, const MuonTrackSteeringStrategy &  strat, const unsigned int  layer, const SegColVec &  segs  ) const

private

Find tracks starting from a good segment.

Parameters

seedSeg	the seeding MuonSegment pointer
strat	the current track finding strategy
layer	the current layer for the seed

Loop over layers following the seed layer

Definition at line 539 of file MuonTrackSteering.cxx.

                                                                                                                                          {
        // the resulting vector of tracks to be returned
        std::vector<std::unique_ptr<MuPatTrack> > result;
        ATH_MSG_DEBUG("Working on seed: " << std::endl << " --- " << m_candidateTool->print(seedSeg));
        const unsigned int endLayer = strat.getAll().size();
        for (unsigned int ilayer = 0; ilayer < strat.getAll().size(); ++ilayer) {
            if (ilayer == layer) continue;  // don't include the layer of the seed
 
            if (segs[ilayer].empty()) continue;
 
            std::vector<MuPatSegment*> matchedSegs;
            bool tightCuts = false;
            //
            if (m_useTightMatching) {
                double phiSeed = (seedSeg.segment)->globalPosition().phi();
                double etaSeed = (seedSeg.segment)->globalPosition().eta();
 
                int segsInCone = 0;
                for (unsigned int j = 0; j < segs[ilayer].size(); j++) {
                    double phiSeg = (*segs[ilayer][j]).segment->globalPosition().phi();
                    double etaSeg = (*segs[ilayer][j]).segment->globalPosition().eta();
 
                    double deltaPhi = xAOD::P4Helpers::deltaPhi(phiSeed, phiSeg);
                    double deltaEta = std::abs(etaSeed - etaSeg);
                    double deltaR = std::hypot(deltaPhi, deltaEta);
 
                    if (deltaR < 0.35) segsInCone++;
                }
 
                if (segsInCone > m_segThreshold) {
                    for (unsigned int j = 0; j < segs[ilayer].size(); ++j) {
                        bool isMatched = m_candidateMatchingTool->match(ctx, seedSeg, *segs[ilayer][j], true);
 
                        if (isMatched) matchedSegs.push_back(segs[ilayer][j]);
                    }
                    if (matchedSegs.empty()) continue;
                    tightCuts = true;
                }
            }
 
            std::vector<std::unique_ptr<MuPatTrack> > tracks;
 
            if (!matchedSegs.empty() && m_useTightMatching)
                tracks = m_trackBTool->find(ctx, seedSeg, matchedSegs);
            else
                tracks = m_trackBTool->find(ctx, seedSeg, segs[ilayer]);
            if (!tracks.empty()) {
                // if we reached the end of the sequence, we should save what we have else continue to next layer
                if (ilayer + 1 == strat.getAll().size()) {
                    result.insert(result.end(), std::make_move_iterator(tracks.begin()), std::make_move_iterator(tracks.end()));
                    break;
                }
 
                // loop on found tracks
                for (std::unique_ptr<MuPatTrack>& cit : tracks) {
                    unsigned int nextLayer = ilayer + 1;
                    if (nextLayer < strat.getAll().size()) {
                        int cutLevel = tightCuts ? 1 : 0;
                        std::vector<std::unique_ptr<MuPatTrack> > nextTracks =
                            extendWithLayer(ctx, *cit, segs, nextLayer, endLayer, cutLevel);
                        if (!nextTracks.empty()) {
                            result.insert(result.end(), std::make_move_iterator(nextTracks.begin()),
                                          std::make_move_iterator(nextTracks.end()));
                        } else {
                            result.push_back(std::move(cit));
                        }
                    }
                }
            }
        }
 
        ATH_MSG_DEBUG("Constructed " << result.size() << " tracks with strategy " << strat.getName());
        return result;
    }

findTracks()

std::unique_ptr< TrackCollection > Muon::MuonTrackSteering::findTracks ( const EventContext &  ctx, SegColVec &  chamberSegments, SegColVec &  stationSegments  ) const

private

actual find method

Definition at line 312 of file MuonTrackSteering.cxx.

                                                                                                                                                      {
        // Very basic : output all of the segments we are starting with
        ATH_MSG_DEBUG("List of all strategies: " << m_strategies.size());
        for (unsigned int i = 0; i < m_strategies.size(); ++i) ATH_MSG_DEBUG((*(m_strategies[i])));
 
        std::vector<std::unique_ptr<MuPatTrack> > resultAll;
 
        // Outermost loop over strategies!
        for (unsigned int i = 0; i < m_strategies.size(); ++i) {
            if (!m_strategies[i]) continue;  // Check for empty strategy pointer
 
            const MuonTrackSteeringStrategy& strategy = *m_strategies[i];
 
            std::vector<std::unique_ptr<MuPatTrack> > result;
 
            // Segments that will be looped over...
            SegColVec mySegColVec(strategy.getAll().size());
 
            ATH_MSG_VERBOSE("Segments to be looped on: " << mySegColVec.size());
 
            std::set<MuonStationIndex::StIndex> stations;
            // Preprocessing : loop over layers
            for (unsigned int lit = 0; lit < strategy.getAll().size(); ++lit) {
                std::vector<MuonStationIndex::ChIndex> chambers = strategy.getCh(lit);
 
                // Optional : combine segments in the same station but different chambers
                if (strategy.option(MuonTrackSteeringStrategy::CombineSegInStation)) {
                    // Loop over stations in the layer
                    for (unsigned int chin = 0; chin < chambers.size(); ++chin) {
                        // get station index for the chamber
                        MuonStationIndex::StIndex stIndex = MuonStationIndex::toStationIndex(chambers[chin]);
 
                        // skip those that are already included
                        if (stations.count(stIndex)) continue;
                        SegCol& segments = stationSegments[stIndex];
                        // Add all of the MuPatSegments into the list for that layer
                        // db
 
                        if (strategy.option(MuonTrackSteeringStrategy::BarrelEndcapFilter)) {
                            // SegCol filteredSegments;
                            for (unsigned int iseg = 0; iseg < segments.size(); iseg++) {
                                double thetaSeg = std::abs((*segments[iseg]).segment->globalPosition().theta());
 
                                // only select segments in barrel/endcap overlap
                                if ((0.74159 > thetaSeg && thetaSeg > 0.51159) || (2.63 > thetaSeg && thetaSeg > 2.40))
                                    mySegColVec[lit].push_back(segments[iseg]);
                            }
                        } else {
                            mySegColVec[lit].insert(mySegColVec[lit].end(), segments.begin(), segments.end());
                        }
 
                        stations.insert(stIndex);
                    }  // End of loop over chambers
 
                } else {
                    // Loop over stations in the layer
                    for (unsigned int chin = 0; chin < chambers.size(); ++chin) {
                        SegCol& segments = chamberSegments[chambers[chin]];
                        // Throw all of the MuPatSegments into the list for that layer
                        mySegColVec[lit].insert(mySegColVec[lit].end(), segments.begin(), segments.end());
                    }  // End of loop over chambers
                }      // End of if combine segments in a layer
 
            }  // End of loop over layers
 
            // Preprocessing step two : sort all layers' segments by quality
            for (unsigned int lit = 0; lit < mySegColVec.size(); ++lit) {
                std::stable_sort(mySegColVec[lit].begin(), mySegColVec[lit].end(), SortSegInfoByQuality());
            }
 
            if (m_doSummary || msgLvl(MSG::DEBUG)) {
                bool hasSegments = false;
                for (unsigned int lit = 0; lit < mySegColVec.size(); ++lit) {
                    if (!mySegColVec[lit].empty()) {
                        hasSegments = true;
                        break;
                    }
                }
                if (hasSegments) {
                    msg(m_doSummary ? MSG::INFO : MSG::DEBUG) << "For strategy: " << strategy.getName() << " segments are: ";
                    for (unsigned int lit = 0; lit < mySegColVec.size(); ++lit)
                        for (unsigned int sit = 0; sit < mySegColVec[lit].size(); ++sit)
                            msg(m_doSummary ? MSG::INFO : MSG::DEBUG) << std::endl
                                                                      << "  " << m_candidateTool->print(*(mySegColVec[lit])[sit]);
                    msg(m_doSummary ? MSG::INFO : MSG::DEBUG) << endmsg;
                }
            }
 
            // Hang on to whether we want to cut seeds or not
            bool cutSeeds = strategy.option(MuonTrackSteeringStrategy::CutSeedsOnTracks);
 
            // Now assign priority for the layers
            std::vector<unsigned int> seeds;
 
            // Assign seeds dynamically according to
            if (strategy.option(MuonTrackSteeringStrategy::DynamicSeeding)) {
                // Loop through layers and do a little sort
                std::vector<std::pair<int, unsigned int> > occupancy;  // layer , occ
                for (unsigned int lit = 0; lit < mySegColVec.size(); ++lit) {
                    occupancy.emplace_back(mySegColVec[lit].size(), lit);
                }
                std::stable_sort(occupancy.begin(), occupancy.end());
                for (unsigned int lit = 0; lit < occupancy.size(); ++lit) { seeds.push_back(occupancy[lit].second); }
            } else {
                seeds = strategy.seeds();
                if (seeds.empty()) {
                    for (unsigned int j = 0; j < mySegColVec.size(); ++j) seeds.push_back(j);
                }
            }
            ATH_MSG_VERBOSE("Selected seed layers " << seeds.size());
 
            MuPatSegment* seedSeg = nullptr;
            // Loop over seed layers
            for (unsigned int lin = 0; lin < seeds.size(); ++lin) {
                // Loop over segments in that layer
                ATH_MSG_VERBOSE("New seed layer " << lin << " segments in layer " << mySegColVec[lin].size());
 
                for (unsigned int sin = 0; sin < mySegColVec[lin].size(); sin++) {
                    seedSeg = mySegColVec[lin].operator[](sin);
                    if (!seedSeg) continue;  // Check for empty poinnter
 
                    // Optionally, if the seed is on a track we skip it
                    if (cutSeeds && seedSeg->usedInFit) continue;
 
                    // See if the seed passes our quality cut
                    if (seedSeg->quality < m_segQCut[0] ||
                        (m_segQCut[0] == -99 && !(seedSeg->segQuality && seedSeg->segQuality->isStrict())))
                        continue;
                    if (m_onlyMDTSeeding && !seedSeg->isMdt) continue;
 
                    int segsInCone = 0;
                    double phiSeed = seedSeg->segment->globalPosition().phi();
                    double etaSeed = seedSeg->segment->globalPosition().eta();
                    for (unsigned int sin2 = 0; sin2 < mySegColVec[lin].size(); sin2++) {
                        if (sin == sin2) continue;
                        MuPatSegment* seg = mySegColVec[lin].operator[](sin2);
 
                        if (seg->quality < m_segQCut[0] || (m_segQCut[0] == -99 && !(seg->segQuality && seg->segQuality->isStrict())))
                            continue;
 
                        double phiSeg = seg->segment->globalPosition().phi();
                        double etaSeg = seg->segment->globalPosition().eta();
 
                        double deltaPhi = xAOD::P4Helpers::deltaPhi(phiSeed, phiSeg);
                        double deltaEta = std::abs(etaSeed - etaSeg);
                        double deltaR = std::hypot(deltaPhi, deltaEta);
 
                        if (deltaR < 0.35) segsInCone++;
                    }
                    ATH_MSG_VERBOSE("New seed " << sin << " segments in cone " << segsInCone);
 
                    if (segsInCone > m_segThreshold && seedSeg->quality < m_segQCut[0] + 1) continue;
 
                    std::vector<std::unique_ptr<MuPatTrack> > found =
                        findTrackFromSeed(ctx, *seedSeg, *(m_strategies[i]), seeds[lin], mySegColVec);
 
                    ATH_MSG_VERBOSE("  Tracks for seed: " << std::endl << " --- " << m_candidateTool->print(result));
                    if (!found.empty()) {
                        result.insert(result.end(), std::make_move_iterator(found.begin()), std::make_move_iterator(found.end()));
                    }
                }  // End of loop over segments in a layer
            }      // Done with loop over seed layers
 
            // Post-processing : refinement
            if (!result.empty() && strategy.option(MuonTrackSteeringStrategy::DoRefinement)) refineTracks(ctx, result);
 
            // Post-processing : ambiguity resolution
            if (msgLvl(MSG::DEBUG) && !result.empty()) {
                msg(MSG::DEBUG) << "Initial track collection for strategy: " << strategy.getName() << "  " << m_candidateTool->print(result)
                                << endmsg;
            }
 
            if (!result.empty() && strategy.option(MuonTrackSteeringStrategy::DoAmbiSolving)) solveAmbiguities(result);
 
            if (!result.empty())
                resultAll.insert(resultAll.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
 
        }  // Done with loop over strategies
 
        if (!resultAll.empty()) { solveAmbiguities(resultAll); }
 
        if (m_outputSingleStationTracks) {
            SegCol& emSegments = stationSegments[MuonStationIndex::EM];
            // loop over segments in EM stations
            if (!emSegments.empty()) {
                for (MuPatSegment* sit : emSegments) {
                    // skip segments that are associated to a track
                    if (!sit->tracks().empty()) continue;
 
                    // only take highest quality segments
                    if (sit->quality < 2) continue;
 
                    // fit segment and add the track if fit ok
                    std::unique_ptr<Trk::Track> segmentTrack(m_segmentFitter->fit(*sit->segment));
                    if (segmentTrack) {
                        // Try to recover hits on the track
                        std::unique_ptr<Trk::Track> recoveredTrack(m_muonHoleRecoverTool->recover(*segmentTrack, ctx));
                        if (recoveredTrack) segmentTrack.swap(recoveredTrack);
 
                        // generate a track summary for this track
                        if (m_trackSummaryTool.isEnabled()) {
                            m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *segmentTrack, false);
                        }
 
                        std::unique_ptr<MuPatTrack> can = m_candidateTool->createCandidate(*sit, segmentTrack);
                        if (can)
                            resultAll.push_back(std::move(can));
                        else
                            ATH_MSG_WARNING("Failed to create MuPatTrack");
                    }
                }
            }
        }
 
        // Output all the tracks that we are ending with
        if (!resultAll.empty()) {
            if (m_doSummary)
                ATH_MSG_INFO("Final Output : " << m_candidateTool->print(resultAll) << endmsg);
            else
                ATH_MSG_DEBUG("Final Output : " << m_candidateTool->print(resultAll) << endmsg);
        }
        std::unique_ptr<TrackCollection> finalTrack = nullptr;
        if (!resultAll.empty()) { finalTrack = selectTracks(resultAll); }
 
        return finalTrack;
    }

initialize()

StatusCode Muon::MuonTrackSteering::initialize ( )

overridevirtual

initialize method, method taken from bass-class AlgTool

Definition at line 65 of file MuonTrackSteering.cxx.

                                             {
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_candidateTool.retrieve());
        ATH_CHECK(m_candidateMatchingTool.retrieve());
        ATH_CHECK(m_trackBTool.retrieve());
        ATH_CHECK(m_ambiTool.retrieve());
        ATH_CHECK(m_mooBTool.retrieve());
        ATH_CHECK(m_trackRefineTool.retrieve());
        ATH_CHECK(m_trackSummaryTool.retrieve());
        ATH_CHECK(decodeStrategyVector(m_stringStrategies));
        if (m_outputSingleStationTracks) ATH_MSG_INFO("Single station track enabled ");
        ATH_CHECK(m_segmentFitter.retrieve(DisableTool{!m_outputSingleStationTracks}));
        ATH_CHECK(m_muonHoleRecoverTool.retrieve(DisableTool{!m_outputSingleStationTracks}));
        ATH_CHECK(m_trackSelector.retrieve(DisableTool{m_trackSelector.empty()}));
        if (!m_trackSelector.empty()) ATH_MSG_INFO("Track selection enabled: " << m_trackSelector);
        
        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()

static const InterfaceID& Muon::IMuonTrackFinder::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 30 of file IMuonTrackFinder.h.

                                                {
            static const InterfaceID IID_IMuonTrackFinder("Muon::IMuonTrackFinder", 1, 0);
            return IID_IMuonTrackFinder; 
        }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

refineTracks()

void Muon::MuonTrackSteering::refineTracks ( const EventContext &  ctx, std::vector< std::unique_ptr< MuPatTrack >> &  candidates  ) const

private

Definition at line 665 of file MuonTrackSteering.cxx.

                                                                                                                         {
        for (std::unique_ptr<MuPatTrack>& cit : candidates) { m_trackRefineTool->refine(ctx, *cit); }
    }

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

selectTracks()

std::unique_ptr< TrackCollection > Muon::MuonTrackSteering::selectTracks ( std::vector< std::unique_ptr< MuPatTrack >> &  candidates, bool  takeOwnership = true  ) const

private

Definition at line 645 of file MuonTrackSteering.cxx.

                                                                                                                                              {
        std::unique_ptr<TrackCollection> result = takeOwnership ?std::make_unique<TrackCollection>() : std::make_unique<TrackCollection>(SG::VIEW_ELEMENTS);
        result->reserve(candidates.size());
        for (std::unique_ptr<MuPatTrack>& cit : candidates) {
            auto & thisTrack =  cit->track();
            // if track selector is configured, use it and remove bad tracks
            if (!m_trackSelector.empty() && !m_trackSelector->decision(thisTrack)) continue;
 
            Trk::Track* track{nullptr};
            if (takeOwnership)
                track = new Trk::Track(thisTrack);
            else
                track = &thisTrack;
            // add track summary to this track
            if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*track, false); }
            result->push_back(track);
        }
        return result;
    }

solveAmbiguities()

void Muon::MuonTrackSteering::solveAmbiguities ( std::vector< std::unique_ptr< MuPatTrack >> &  tracks, const MuonTrackSteeringStrategy *  strat = nullptr  ) const

private

Resolve ambiguities among tracks for a single strategy This allows a strategy-specific ambiguity solving (with some options per strategy)

Parameters

vector	of tracks that were found
strat	the steering strategy

Definition at line 671 of file MuonTrackSteering.cxx.

                                                                                       {
        // the resulting vector of tracks to be returned
        std::unique_ptr<TrackCollection> trkColl(selectTracks(tracks, false));
        if (!trkColl || trkColl->empty()) { return; }
 
        std::unique_ptr<const TrackCollection> resolvedTracks(m_ambiTool->process(trkColl.get()));
        if (!resolvedTracks) { return; }
 
        ATH_MSG_DEBUG("   resolved track candidates: old size " << trkColl->size() << " new size " << resolvedTracks->size());
 
        std::vector<std::unique_ptr<MuPatTrack> >::iterator pat = tracks.begin();
        for (; pat != tracks.end();) {
            bool found = false;
            for (const Trk::Track* rtrk : *resolvedTracks) {
                if (&(*pat)->track() == rtrk) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                pat = tracks.erase(pat);
            } else {
                ++pat;
            }
        }
 
    }

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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_ambiTool

ToolHandle<Trk::ITrackAmbiguityProcessorTool> Muon::MuonTrackSteering::m_ambiTool

private

Initial value:

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

Definition at line 135 of file MuonTrackSteering.h.

m_candidateMatchingTool

ToolHandle<MooCandidateMatchingTool> Muon::MuonTrackSteering::m_candidateMatchingTool

private

Initial value:

{this, "CandidateMatchingTool",
                                                                     "Muon::MooCandidateMatchingTool/MooCandidateMatchingTool"}

Definition at line 138 of file MuonTrackSteering.h.

m_candidateTool

ToolHandle<MuPatCandidateTool> Muon::MuonTrackSteering::m_candidateTool {this, "MuPatCandidateTool", "Muon::MuPatCandidateTool/MuPatCandidateTool"}

private

Definition at line 133 of file MuonTrackSteering.h.

m_combinedSLOverlaps

bool Muon::MuonTrackSteering::m_combinedSLOverlaps

private

Definition at line 154 of file MuonTrackSteering.h.

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_doSummary

bool Muon::MuonTrackSteering::m_doSummary

private

Definition at line 155 of file MuonTrackSteering.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuonTrackSteering::m_edmHelperSvc

private

Initial value:

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

Definition at line 130 of file MuonTrackSteering.h.

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_mooBTool

ToolHandle<MooTrackBuilder> Muon::MuonTrackSteering::m_mooBTool {this, "MooBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}

private

Definition at line 137 of file MuonTrackSteering.h.

m_muonHoleRecoverTool

ToolHandle<IMuonHoleRecoveryTool> Muon::MuonTrackSteering::m_muonHoleRecoverTool

private

Initial value:

{this, "HoleRecoveryTool",
                                                                "Muon::MuonChamberHoleRecoveryTool/MuonChamberHoleRecoveryTool"}

Definition at line 145 of file MuonTrackSteering.h.

m_onlyMDTSeeding

bool Muon::MuonTrackSteering::m_onlyMDTSeeding

private

Definition at line 157 of file MuonTrackSteering.h.

m_outputSingleStationTracks

bool Muon::MuonTrackSteering::m_outputSingleStationTracks

private

Definition at line 153 of file MuonTrackSteering.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonTrackSteering::m_printer {this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

private

Definition at line 132 of file MuonTrackSteering.h.

m_segmentFitter

ToolHandle<IMuonSegmentFittingTool> Muon::MuonTrackSteering::m_segmentFitter

private

Initial value:

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

Definition at line 141 of file MuonTrackSteering.h.

m_segQCut

std::array<int, 3> Muon::MuonTrackSteering::m_segQCut {}

private

Required segment quality for seed, 2nd, and other segments.

Definition at line 152 of file MuonTrackSteering.h.

m_segThreshold

int Muon::MuonTrackSteering::m_segThreshold

private

Definition at line 158 of file MuonTrackSteering.h.

m_strategies

std::vector<std::unique_ptr<const MuonTrackSteeringStrategy> > Muon::MuonTrackSteering::m_strategies

private

Definition at line 149 of file MuonTrackSteering.h.

m_stringStrategies

std::vector<std::string> Muon::MuonTrackSteering::m_stringStrategies

private

Definition at line 150 of file MuonTrackSteering.h.

m_trackBTool

ToolHandle<IMuonTrackBuilder> Muon::MuonTrackSteering::m_trackBTool {this, "TrackBuilderTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}

private

Definition at line 134 of file MuonTrackSteering.h.

m_trackRefineTool

ToolHandle<IMuonTrackRefiner> Muon::MuonTrackSteering::m_trackRefineTool {this, "TrackRefinementTool", "Muon::MooTrackBuilder/MooMuonTrackBuilder"}

private

Definition at line 140 of file MuonTrackSteering.h.

m_trackSelector

ToolHandle<Muon::MuonTrackSelectorTool> Muon::MuonTrackSteering::m_trackSelector

private

Initial value:

{this, "MuonTrackSelector",
                                                                "Muon::MuonTrackSelectorTool/MuonTrackSelectorTool"}

Definition at line 143 of file MuonTrackSteering.h.

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> Muon::MuonTrackSteering::m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}

private

Definition at line 147 of file MuonTrackSteering.h.

m_useTightMatching

bool Muon::MuonTrackSteering::m_useTightMatching

private

Definition at line 156 of file MuonTrackSteering.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

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:

• MuonTrackSteering.h
• MuonTrackSteering.cxx