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
using	StSegCol_t = std::array< SegCol, MuonStationIndex::toInt(MuonStationIndex::StIndex::StIndexMax)>
	Helper container to sort the segments by station index. More...
using	ChSegCol_t = std::array< SegCol, MuonStationIndex::toInt(MuonStationIndex::ChIndex::ChIndexMax)>
	Helper container to sort the segments by chamber index. More...
using	SegColVec_t = std::vector< SegCol >
	More...
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...

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, ChSegCol_t &chamberSegments, StSegCol_t &stationSegments) const
	actual find method More...
bool	extractSegments (const EventContext &ctx, const MuonSegmentCollection &coll, ChSegCol_t &chamberSegments, StSegCol_t &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_t &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_t &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, StSegCol_t &stationSegments, StSet &stationsWithSegments, GarbageContainer &trash_bin) const

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

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 65 of file MuonTrackSteering.h.

ChIt

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

Definition at line 64 of file MuonTrackSteering.h.

ChSegCol_t

using Muon::MuonTrackSteering::ChSegCol_t = std::array<SegCol, MuonStationIndex::toInt(MuonStationIndex::ChIndex::ChIndexMax)>

Helper container to sort the segments by chamber index.

Definition at line 60 of file MuonTrackSteering.h.

ChSet

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

Definition at line 63 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_t

using Muon::MuonTrackSteering::SegColVec_t = std::vector<SegCol>

Definition at line 62 of file MuonTrackSteering.h.

StCit

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

Definition at line 69 of file MuonTrackSteering.h.

StIt

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

Definition at line 68 of file MuonTrackSteering.h.

StSegCol_t

using Muon::MuonTrackSteering::StSegCol_t = std::array<SegCol, MuonStationIndex::toInt(MuonStationIndex::StIndex::StIndexMax)>

Helper container to sort the segments by station index.

Definition at line 58 of file MuonTrackSteering.h.

StSet

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

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

                                                                                                    : 
        base_class(t,n,p), m_combinedSLOverlaps(false) {
 
        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, StSegCol_t &  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
        StIndex stIndex = !ch1.empty() ? ch1.front()->stIndex : ch2.front()->stIndex;
 
        SegCol& stationVec = stationSegments[toInt(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 || segInfo->quality < 2 || (segInfo->quality < sit1->quality || segInfo->quality < sit2->quality)) {
                    if(segInfo) ATH_MSG_VERBOSE("resolveSLOverlaps::bad segment " << std::endl << m_printer->print(*segInfo->segment));
                    else ATH_MSG_VERBOSE("Invalid segment info");
                    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());
    }

decodeList()

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

staticprivate

Definition at line 806 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 720 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<ChIndex> > path;
            for (unsigned int i = 0; i < sequence.size(); ++i) {
                std::vector<ChIndex> idxGrp;
                for (unsigned int j = 0; j < sequence[i].size(); ++j) {
                    ChIndex idx = chIndex(sequence[i][j]);
                    if (ChIndex::ChUnknown == idx) {
                        ATH_MSG_WARNING("I am complaining: Bad station index.");
                    } 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 703 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;
    }

extendWithLayer()

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

private

Definition at line 618 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, ChSegCol_t &  chamberSegments, StSegCol_t &  stationSegments, ChSet &  chambersWithSegments, StSet &  stationsWithSegments, GarbageContainer &  trash_bin  ) const

private

Definition at line 102 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);
            if (!aSeg) continue;
            ATH_MSG_DEBUG(" -> MuPatSegment " << m_candidateTool->print(*aSeg));
 
            ChIndex chIndex = aSeg->chIndex;
            StIndex stIndex = aSeg->stIndex;
            if (chIndex == ChIndex::ChUnknown || stIndex ==  StIndex::StUnknown) {
                ATH_MSG_WARNING("Chamber or station index invalid:" << m_candidateTool->print(*aSeg));
                continue;
            }
            chambersWithSegments.insert(chIndex);
            stationsWithSegments.insert(stIndex);
 
            std::vector<MuPatSegment*>& segments = chamberSegments[toInt(chIndex)];
            segments.push_back(aSeg.get());
            if (!m_combinedSLOverlaps) {
                std::vector<MuPatSegment*>& segments2 = stationSegments[toInt(stIndex)];
                segments2.push_back(aSeg.get());
            }
            trash_bin.push_back(std::move(aSeg));
        }
 
        if (m_combinedSLOverlaps) {
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::BIS)], chamberSegments[toInt(ChIndex::BIL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::BMS)], chamberSegments[toInt(ChIndex::BML)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::BOS)], chamberSegments[toInt(ChIndex::BOL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::EIS)], chamberSegments[toInt(ChIndex::EIL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::EMS)], chamberSegments[toInt(ChIndex::EML)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::EOS)], chamberSegments[toInt(ChIndex::EOL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::EES)], chamberSegments[toInt(ChIndex::EEL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            combineOverlapSegments(ctx, chamberSegments[toInt(ChIndex::CSS)], chamberSegments[toInt(ChIndex::CSL)], stationSegments,
                                   stationsWithSegments, trash_bin);
            std::vector<MuPatSegment*>& segments = chamberSegments[toInt(ChIndex::BEE)];
            if (!segments.empty()) {
                chambersWithSegments.insert(ChIndex::BEE);
                stationsWithSegments.insert(StIndex::BE);
                std::vector<MuPatSegment*>& segs = stationSegments[toInt(StIndex::BE)];
                segs.insert(segs.end(), segments.begin(), segments.end());
            }
        }
        return true;
    }

find()

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 84 of file MuonTrackSteering.cxx.

                                                                                                                           {
        GarbageContainer trash_bin{};
        trash_bin.reserve(150);
 
        std::unique_ptr<TrackCollection> result = std::make_unique<TrackCollection>();
 
        ChSegCol_t chamberSegments{};  // <! Segments sorted per Chamber
        StSegCol_t stationSegments{};  // <! 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;
    }

findTrackFromSeed()

std::vector< std::unique_ptr< MuPatTrack > > Muon::MuonTrackSteering::findTrackFromSeed ( const EventContext &  ctx, MuPatSegment &  seedSeg, const MuonTrackSteeringStrategy &  strat, const unsigned int  layer, const SegColVec_t &  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 540 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, ChSegCol_t &  chamberSegments, StSegCol_t &  stationSegments  ) const

private

actual find method

Definition at line 313 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_t mySegColVec(strategy.getAll().size());
 
            ATH_MSG_VERBOSE("Segments to be looped on: " << mySegColVec.size());
 
            std::set<StIndex> stations;
            // Preprocessing : loop over layers
            for (unsigned int lit = 0; lit < strategy.getAll().size(); ++lit) {
                std::vector<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
                        StIndex stIndex = toStationIndex(chambers[chin]);
 
                        // skip those that are already included
                        if (stations.count(stIndex)) continue;
                        SegCol& segments = stationSegments[toInt(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[toInt(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[toInt(StIndex::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 64 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;
    }

refineTracks()

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

private

Definition at line 666 of file MuonTrackSteering.cxx.

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

selectTracks()

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

private

Definition at line 646 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 672 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;
            }
        }
 
    }

Member Data Documentation

m_ambiTool

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

private

Initial value:

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

Definition at line 137 of file MuonTrackSteering.h.

m_candidateMatchingTool

ToolHandle<MooCandidateMatchingTool> Muon::MuonTrackSteering::m_candidateMatchingTool

private

Initial value:

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

Definition at line 140 of file MuonTrackSteering.h.

m_candidateTool

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

private

Definition at line 135 of file MuonTrackSteering.h.

m_combinedSLOverlaps

bool Muon::MuonTrackSteering::m_combinedSLOverlaps

private

Definition at line 156 of file MuonTrackSteering.h.

m_doSummary

bool Muon::MuonTrackSteering::m_doSummary

private

Definition at line 157 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 132 of file MuonTrackSteering.h.

m_mooBTool

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

private

Definition at line 139 of file MuonTrackSteering.h.

m_muonHoleRecoverTool

ToolHandle<IMuonHoleRecoveryTool> Muon::MuonTrackSteering::m_muonHoleRecoverTool

private

Initial value:

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

Definition at line 147 of file MuonTrackSteering.h.

m_onlyMDTSeeding

bool Muon::MuonTrackSteering::m_onlyMDTSeeding

private

Definition at line 159 of file MuonTrackSteering.h.

m_outputSingleStationTracks

bool Muon::MuonTrackSteering::m_outputSingleStationTracks

private

Definition at line 155 of file MuonTrackSteering.h.

m_printer

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

private

Definition at line 134 of file MuonTrackSteering.h.

m_segmentFitter

ToolHandle<IMuonSegmentFittingTool> Muon::MuonTrackSteering::m_segmentFitter

private

Initial value:

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

Definition at line 143 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 154 of file MuonTrackSteering.h.

m_segThreshold

int Muon::MuonTrackSteering::m_segThreshold

private

Definition at line 160 of file MuonTrackSteering.h.

m_strategies

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

private

Definition at line 151 of file MuonTrackSteering.h.

m_stringStrategies

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

private

Definition at line 152 of file MuonTrackSteering.h.

m_trackBTool

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

private

Definition at line 136 of file MuonTrackSteering.h.

m_trackRefineTool

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

private

Definition at line 142 of file MuonTrackSteering.h.

m_trackSelector

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

private

Initial value:

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

Definition at line 145 of file MuonTrackSteering.h.

m_trackSummaryTool

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

private

Definition at line 149 of file MuonTrackSteering.h.

m_useTightMatching

bool Muon::MuonTrackSteering::m_useTightMatching

private

Definition at line 158 of file MuonTrackSteering.h.

---

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

• MuonTrackSteering.h
• MuonTrackSteering.cxx