Muon::MooTrackBuilder Class Reference

Tool to combine two segments or a track and a segment to a track. More...

#include <MooTrackBuilder.h>

Inheritance diagram for Muon::MooTrackBuilder:

Collaboration diagram for Muon::MooTrackBuilder:

Public Types
using	PrepVec = std::vector<const Trk::PrepRawData*>
typedef PrepVec::iterator	PrepIt
typedef PrepVec::const_iterator	PrepCit

Public Member Functions
	MooTrackBuilder (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor
	~MooTrackBuilder ()=default
	destructor
virtual StatusCode	initialize () override
	initialize method, method taken from bass-class AlgTool
virtual StatusCode	finalize () override
	finialize method, method taken from bass-class AlgTool
virtual std::unique_ptr< Trk::Track >	refit (const EventContext &ctx, Trk::Track &track) const override
	refit track
std::unique_ptr< MuonSegment >	combineToSegment (const EventContext &ctx, const MuPatCandidateBase &firstEntry, const MuPatCandidateBase &secondEntry, const PrepVec &patternPhiHits) const
	Methos is used externally by MuonTrackSteering.cxx:233. Should be revised to put it into an interface.
virtual std::unique_ptr< MuonSegment >	combineToSegment (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2, const PrepVec &patternPhiHits) const override
	combine two segments to a super segment
virtual std::unique_ptr< Trk::Track >	combine (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2, const PrepVec &patternPhiHits) const override
	combine two segments to a track
virtual std::unique_ptr< Trk::Track >	combine (const EventContext &ctx, const Trk::Track &track, const MuonSegment &seg, const PrepVec &patternPhiHits) const override
	combine a track with a segment
virtual std::unique_ptr< Trk::TrackParameters >	findClosestParameters (const Trk::Track &track, const Amg::Vector3D &pos) const override
	find closest TrackParameters to the position.
virtual std::unique_ptr< Trk::TrackParameters >	getClosestParameters (const Trk::Track &track, const Trk::Surface &surf) const override
	find closest TrackParameters to the surface.
std::unique_ptr< Trk::TrackParameters >	getClosestParameters (const MuPatCandidateBase &candidate, const Trk::Surface &surf) const
	find closest TrackParameters to the surface.
virtual std::unique_ptr< Trk::Track >	recalibrateHitsOnTrack (const EventContext &ctx, const Trk::Track &track, bool doMdts, bool doCompetingClusters) const override
	recalibrate hits on track
virtual std::vector< std::unique_ptr< MuPatTrack > >	find (const EventContext &ctx, MuPatCandidateBase &candidate, const std::vector< MuPatSegment * > &segments) const override
	interface for tools to find track in the muon system starting from a vector of segments
virtual void	refine (const EventContext &ctx, MuPatTrack &track) const override
	interface for tools which refine the hit content of a given track
	DeclareInterfaceID (Muon::IMuonSegmentTrackBuilder, 1, 0)
	access to tool interface
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< Trk::Track >	combine (const EventContext &ctx, const MuPatCandidateBase &firstEntry, const MuPatCandidateBase &secondEntry, const PrepVec &patternPhiHits) const
	combine two MCTBCandidateEntries
std::vector< std::unique_ptr< Trk::Track > >	combineWithSegmentFinding (const EventContext &ctx, const Trk::Track &track, const MuonSegment &seg, const PrepVec &patternPhiHits) const
	find tracks by redoing the segment finding in the chamber of the segment
std::vector< std::unique_ptr< Trk::Track > >	combineWithSegmentFinding (const EventContext &ctx, const MuPatTrack &candidate, const MuPatSegment &segInfo, const PrepVec &patternPhiHits) const
	find tracks by redoing the segment finding in the chamber of the segment
std::vector< std::unique_ptr< Trk::Track > >	combineWithSegmentFinding (const EventContext &ctx, const MuPatTrack &candidate, const Trk::TrackParameters &pars, const std::set< Identifier > &chIds, const PrepVec &patternPhiHits) const
	find tracks by redoing the segment finding in the chamber of the segment
std::vector< std::unique_ptr< Trk::Track > >	combineWithSegmentFinding (const EventContext &ctx, const Trk::Track &track, const Trk::TrackParameters &pars, const std::set< Identifier > &chIds, const PrepVec &patternPhiHits) const
	find tracks by redoing the segment finding in the chamber of the segment
std::pair< std::unique_ptr< Trk::Track >, std::unique_ptr< Trk::Track > >	splitTrack (const EventContext &ctx, const Trk::Track &track) const
	split given track if it crosses the calorimeter volume, code assumes that the track was already extrapolated to the muon entry record using the MuonTrackExtrapolationTool.
bool	isSplitTrack (const EventContext &ctx, const Trk::Track &track1, const Trk::Track &track2) const
	identify whether two track are split
TrackCollection *	mergeSplitTracks (const EventContext &ctx, const TrackCollection &tracks) const
	look for split tracks in collection and merge them
void	removeDuplicateWithReference (std::unique_ptr< Trk::SegmentCollection > &segments, std::vector< const MuonSegment * > &referenceSegments) const
Trk::TrackStates::const_iterator	insertClustersWithCompetingRotCreation (const EventContext &ctx, Trk::TrackStates::const_iterator tsit, Trk::TrackStates::const_iterator tsit_end, std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > &states) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< MooTrackFitter >	m_fitter {this, "Fitter", "Muon::MooTrackFitter/MooTrackFitter", "Tool to fit segments to tracks"}
ToolHandle< MooTrackFitter >	m_slFitter {this, "SLFitter", "Muon::MooTrackFitter/MooSLTrackFitter", "Tool to fit segments to tracks"}
ToolHandle< MuPatCandidateTool >	m_candidateHandler
	candidate handler
ToolHandle< MooCandidateMatchingTool >	m_candidateMatchingTool
ToolHandle< IMuonTrackToSegmentTool >	m_trackToSegmentTool
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
PublicToolHandle< MuonEDMPrinterTool >	m_printer
	tool to print out EDM objects;
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< IMuonSeededSegmentFinder >	m_seededSegmentFinder
ToolHandle< IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
ToolHandle< IMuonCompetingClustersOnTrackCreator >	m_compRotCreator
ToolHandle< Trk::IPropagator >	m_propagator {this, "Propagator", "Trk::STEP_Propagator/MuonPropagator"}
ToolHandle< Trk::IResidualPullCalculator >	m_pullCalculator
ToolHandle< IMuonHoleRecoveryTool >	m_muonChamberHoleRecoverTool
ToolHandle< IMuonTrackExtrapolationTool >	m_trackExtrapolationTool
ToolHandle< IMuonErrorOptimisationTool >	m_errorOptimisationTool {this, "ErrorOptimisationTool", ""}
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
Trk::MagneticFieldProperties	m_magFieldProperties {Trk::FullField}
	magnetic field properties
Gaudi::Property< bool >	m_doTimeOutChecks {this, "UseTimeOutGuard", true}
	on/off time out check
Gaudi::Property< bool >	m_useExclusionList
	use exclusion list (bit faster at the price of missing chambers)
Gaudi::Property< bool >	m_useTrackingHistory
	use history of the track finding up to now to avoid creating duplicates
Gaudi::Property< bool >	m_recalibrateMDTHits {this, "RecalibrateMDTHitsOnTrack", true}
std::atomic_uint	m_ncalls {0}
std::atomic_uint	m_nTimedOut {0}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Tool to combine two segments or a track and a segment to a track.

In addition it offers the possibility to combine two segments to one larger segment.

The tool can either be configured to perform a straight line association or an association in the magnetic field.

The following steps are performed:

• simple match of the input using the MuonSegmentTrackMatcher
• if match successfull, fit of the input using the MuonSegmentTrackFitter
• if a track was found, cleaning of the track using the MuonTrackCleaner
• final decision whether to keep track or not

For more details look at the mainpage of this package.

Definition at line 82 of file MooTrackBuilder.h.

Member Typedef Documentation

PrepCit

typedef PrepVec::const_iterator Muon::IMuonSegmentTrackBuilder::PrepCit

inherited

Definition at line 28 of file IMuonSegmentTrackBuilder.h.

PrepIt

typedef PrepVec::iterator Muon::IMuonSegmentTrackBuilder::PrepIt

inherited

Definition at line 27 of file IMuonSegmentTrackBuilder.h.

PrepVec

using Muon::IMuonSegmentTrackBuilder::PrepVec = std::vector<const Trk::PrepRawData*>

inherited

Definition at line 26 of file IMuonSegmentTrackBuilder.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MooTrackBuilder()

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

default AlgTool constructor

Definition at line 30 of file MooTrackBuilder.cxx.

                                                                                                : AthAlgTool(t, n, p) {
        declareInterface<IMuonSegmentTrackBuilder>(this);
        declareInterface<MooTrackBuilder>(this);
        declareInterface<IMuonTrackRefiner>(this);
        declareInterface<IMuonTrackBuilder>(this);
    }

~MooTrackBuilder()

Muon::MooTrackBuilder::~MooTrackBuilder ( )

default

destructor

Member Function Documentation

combine() [1/3]

std::unique_ptr< Trk::Track > Muon::MooTrackBuilder::combine ( const EventContext & ctx, const MuonSegment & seg1, const MuonSegment & seg2, const PrepVec & patternPhiHits ) const

overridevirtual

combine two segments to a track

Parameters

seg1	the first segment
seg2	the second segment
externalPhiHits	if provided, the external phi hits will be used instead of the phi hits on the segment

Returns

a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 151 of file MooTrackBuilder.cxx.

                                                                                               {
 
        // convert segments
        std::unique_ptr<MuPatSegment> segInfo1{m_candidateHandler->createSegInfo(ctx, seg1)};
        if (!segInfo1) {return nullptr; }
        std::unique_ptr<MuPatSegment> segInfo2{m_candidateHandler->createSegInfo(ctx, seg2)};
        if (!segInfo2) { return nullptr; }
 
        // call fit()
        return combine(ctx, *segInfo1, *segInfo2, externalPhiHits);
    }

combine() [2/3]

std::unique_ptr< Trk::Track > Muon::MooTrackBuilder::combine ( const EventContext & ctx, const MuPatCandidateBase & firstEntry, const MuPatCandidateBase & secondEntry, const PrepVec & patternPhiHits ) const

private

combine two MCTBCandidateEntries

Parameters

firstEntry	the first entry
secondEntry	the second entry
externalPhiHits	if provided, the external phi hits will be used instead of the phi hits on the segment

Returns

a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.

Definition at line 178 of file MooTrackBuilder.cxx.

                                                                                                                                          {
        ++m_ncalls;
 
        if (m_doTimeOutChecks && Athena::Timeout::instance(ctx).reached()) {
            ATH_MSG_DEBUG("Timeout reached. Aborting sequence.");
            ++m_nTimedOut;
            return nullptr;
        }
 
        std::set<MuonStationIndex::StIndex> stations = firstCandidate.stations();
        stations.insert(secondCandidate.stations().begin(), secondCandidate.stations().end());
        unsigned int nstations = stations.size();
 
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
        const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
        if (!fieldCondObj) {
            ATH_MSG_ERROR("combine: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return nullptr;
        }
        fieldCondObj->getInitializedCache(fieldCache);
        using namespace MuonStationIndex;
        bool slFit = !fieldCache.toroidOn() || nstations == 1 || 
                    (nstations == 2 && (stations.count(StIndex::EM) &&
                                        (stations.count(StIndex::BO) || stations.count(StIndex::EO))));
        if (msgLvl(MSG::DEBUG)) {
            msg(MSG::DEBUG) << MSG::DEBUG << " combining entries: nstations " << nstations << " types:";
            for (std::set<StIndex>::const_iterator it = stations.begin(); it != stations.end(); ++it) {
                msg(MSG::DEBUG) << MSG::DEBUG << "  " << stName(*it);
            }
            if (slFit) {
                msg(MSG::DEBUG) << " doing SL fit ";
            } else {
                msg(MSG::DEBUG) << " doing curved fit ";
            }
            msg(MSG::DEBUG) << endmsg;
        }
 
        const MuPatTrack* trkCan1 = dynamic_cast<const MuPatTrack*>(&firstCandidate);
        const MuPatTrack* trkCan2 = dynamic_cast<const MuPatTrack*>(&secondCandidate);
 
        const MuPatSegment* segCan1 = dynamic_cast<const MuPatSegment*>(&firstCandidate);
        const MuPatSegment* segCan2 = dynamic_cast<const MuPatSegment*>(&secondCandidate);
 
        const MuPatTrack* candidate = nullptr;
        const MuPatSegment* segment = nullptr;
        if (trkCan1 && segCan2) {
            candidate = trkCan1;
            segment = segCan2;
        } else if (trkCan2 && segCan1) {
            candidate = trkCan2;
            segment = segCan1;
        }
 
        // check whether this combination was already tried, if yes reject the combination
        if (candidate && segment) {
            ATH_MSG_DEBUG(" Track/segment combination");
            const std::vector<MuPatSegment*>& excl = candidate->excludedSegments();
            if (std::find(excl.begin(),excl.end(), segment) != excl.end()){
                ATH_MSG_DEBUG(" Rejected segment based on exclusion list");
                return nullptr;
            }
        }
 
        // the following bit of code checks whether the current combination of segments was already tested
        if (m_useTrackingHistory) {
            // create a set of all segments of the would-be candidate
            std::set<const MuPatSegment*> segments;
            if ((segCan1 && segCan2)) {
                segments.insert(segCan1);
                segments.insert(segCan2);
            }
            if (candidate && segment) {
                segments.insert(segment);
                segments.insert(candidate->segments().begin(), candidate->segments().end());
            }
            // now loop over the segments and check if any of them is associated with a track that contains all of the segments
 
            for (const MuPatSegment* used : segments) {
                // loop over the tracks associated with the current segment
                for (const MuPatTrack* assoc_track : used->tracks()) {
                    // loop over the segments associated with the track
                    std::set<const MuPatSegment*> foundSegments;
                    for (const MuPatSegment* segOnTrack : assoc_track->segments()) {
                        if (segments.count(segOnTrack)) foundSegments.insert(segOnTrack);
                    }
                    // if all segments are already part of an existing track, don't perform the fit
                    if (foundSegments.size() == segments.size()) {
                        ATH_MSG_DEBUG("Combination already part of an existing track");
                        return nullptr;
                    }
 
                    // if all segments but one are already part of an existing track, check the exclusion list
                    if (candidate && !candidate->excludedSegments().empty() && foundSegments.size() == segments.size() - 1) {
                        // create destination vector for segments that are not found
                        std::vector<const MuPatSegment*> unassociatedSegments(segments.size(), nullptr);
                        std::vector<const MuPatSegment*>::iterator it = std::set_difference(
                            segments.begin(), segments.end(), foundSegments.begin(), foundSegments.end(), unassociatedSegments.begin());
                        const MuPatSegment* zero = nullptr;
                        unassociatedSegments.erase(std::find(unassociatedSegments.begin(), unassociatedSegments.end(), zero),
                                                   unassociatedSegments.end());
 
                        // check whether any pointers found
                        if (it != unassociatedSegments.begin()) {
                            // this should always be one as we required the difference to be one!
                            if (unassociatedSegments.size() != 1) {
                                ATH_MSG_DEBUG("Inconsistent result from set difference: size result "
                                              << unassociatedSegments.size() << " candidate " << segments.size() << " found "
                                              << foundSegments.size());
                                return nullptr;
                            }
 
                            // check that the result is indeed part of the original set
                            if (!segments.count(unassociatedSegments.front())) {
                                ATH_MSG_DEBUG("Segment point not part of the original set, aborting!");
                                return nullptr;
                            }
 
                            // now check whether the segment is part of the excluded segments
                            std::vector<MuPatSegment*>::const_iterator pos = std::find(
                                candidate->excludedSegments().begin(), candidate->excludedSegments().end(), unassociatedSegments.front());
                            if (pos != candidate->excludedSegments().end()) {
                                ATH_MSG_DEBUG("Segment found in exclusion list, not performing fit");
                                return nullptr;
                            }
                        }
                    }
                }
            }
        }
 
        // use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
        if (slFit) return std::unique_ptr<Trk::Track>(m_slFitter->fit(ctx, firstCandidate, secondCandidate, externalPhiHits));
 
        return m_fitter->fit(ctx, firstCandidate, secondCandidate, externalPhiHits);
    }

combine() [3/3]

std::unique_ptr< Trk::Track > Muon::MooTrackBuilder::combine ( const EventContext & ctx, const Trk::Track & track, const MuonSegment & seg, const PrepVec & patternPhiHits ) const

overridevirtual

combine a track with a segment

Parameters

track	a track
seg	a segment
externalPhiHits	if provided, the external phi hits will be used instead of the phi hits on the segment

Returns

a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 318 of file MooTrackBuilder.cxx.

                                                                                               {
 
        // convert segments
        std::unique_ptr<Trk::Track> inTrack = std::make_unique<Trk::Track>(track);
        std::unique_ptr<MuPatTrack> candidate(m_candidateHandler->createCandidate(inTrack));
        if (!candidate) return nullptr;
        std::unique_ptr<MuPatSegment> segInfo(m_candidateHandler->createSegInfo(ctx, seg));
        if (!segInfo) { return nullptr; }
 
        // call fit()
        return  combine(ctx, *candidate, *segInfo, externalPhiHits);
    }

combineToSegment() [1/2]

std::unique_ptr< MuonSegment > Muon::MooTrackBuilder::combineToSegment ( const EventContext & ctx, const MuonSegment & seg1, const MuonSegment & seg2, const PrepVec & patternPhiHits ) const

overridevirtual

combine two segments to a super segment

Parameters

seg1	the first segment
seg2	the second segment
externalPhiHits	if provided, the external phi hits will be used instead of the phi hits on the segment

Returns

a pointer to the combined segment, will return zero if combination failed. Ownership passed to user.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 138 of file MooTrackBuilder.cxx.

                                                                                                                                                                                {
        // try to get track
        std::unique_ptr<Trk::Track> track = combine(ctx, seg1, seg2, externalPhiHits);
 
        if (!track) return nullptr;
 
        // create MuonSegment
        std::unique_ptr<MuonSegment> seg{m_trackToSegmentTool->convert(ctx, *track)};
        if (!seg) { ATH_MSG_WARNING(" conversion of track failed!! "); }
 
        return seg;
    }

combineToSegment() [2/2]

std::unique_ptr< MuonSegment > Muon::MooTrackBuilder::combineToSegment	(	const EventContext &	ctx,
		const MuPatCandidateBase &	firstEntry,
		const MuPatCandidateBase &	secondEntry,
		const PrepVec &	patternPhiHits ) const

Methos is used externally by MuonTrackSteering.cxx:233. Should be revised to put it into an interface.

combine two MCTBCandidateEntries

Parameters

firstEntry	the first entry
secondEntry	the second entry
externalPhiHits	if provided, the external phi hits will be used instead of the phi hits on the segment

Returns

a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.

Definition at line 164 of file MooTrackBuilder.cxx.

                                                                                         {
        // try to get track
        std::unique_ptr<Trk::Track> track = combine(ctx, firstCandidate, secondCandidate, externalPhiHits);
 
        if (!track) return nullptr;
 
        // create MuonSegment
        std::unique_ptr<MuonSegment> seg{m_trackToSegmentTool->convert(ctx, *track)};
        if (!seg) { ATH_MSG_WARNING(" conversion of track failed!! "); }
 
        return seg;
    }

combineWithSegmentFinding() [1/4]

std::vector< std::unique_ptr< Trk::Track > > Muon::MooTrackBuilder::combineWithSegmentFinding ( const EventContext & ctx, const MuPatTrack & candidate, const MuPatSegment & segInfo, const PrepVec & patternPhiHits ) const

private

find tracks by redoing the segment finding in the chamber of the segment

Parameters

candidate	a reference to a MuPatTrack
segInfo	a reference to a MuPatSegment

Returns

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

second stage segment matching:

• estimate segment parameters at segment position using fit of track + segment position
• redo segment finding using the predicted parameters as seed
• redo segment association

Definition at line 426 of file MooTrackBuilder.cxx.

                                                                                                                               {
 
        const MuonSegment& seg = *segInfo.segment;
        std::vector<std::unique_ptr<Trk::Track> > newTracks;
 
        // get chamber Id of segment
        std::set<Identifier> chIds = m_edmHelperSvc->chamberIds(seg);
 
        if (chIds.empty()) return newTracks;
 
        // for now do not redo segment making for CSCs
        if (m_idHelperSvc->isCsc(*chIds.begin())) {
            if (m_candidateMatchingTool->match(ctx, candidate, segInfo, true)) {
                std::unique_ptr<Trk::Track> newtrack(m_fitter->fit(ctx, candidate, segInfo, externalPhiHits));
                if (newtrack) newTracks.push_back(std::move(newtrack));
                return newTracks;
            } else {
                return newTracks;
            }
        }
 
        const Trk::Track& track = candidate.track();
        ATH_MSG_DEBUG(" in combineWithSegmentFinding ");
        ATH_MSG_VERBOSE(" segment " << m_printer->print(seg));
 
        // find track parameters on segment surface
        std::unique_ptr<Trk::TrackParameters> closestPars(findClosestParameters(track, seg.globalPosition()));
 
        if (!closestPars) {
            ATH_MSG_WARNING(" unable to find closest TrackParameters ");
            return newTracks;
        }
 
        ATH_MSG_VERBOSE(" closest parameter " << m_printer->print(*closestPars));
 
        // propagate to segment surface
        std::unique_ptr<Trk::TrackParameters> exPars(
            m_propagator->propagate(ctx,*closestPars, seg.associatedSurface(), Trk::anyDirection, false, m_magFieldProperties));
 
        if (!exPars) {
            ATH_MSG_WARNING(" Propagation failed!! ");
            return newTracks;
        }
 
        ATH_MSG_VERBOSE(" extrapolated parameter " << m_printer->print(*exPars));
 
        return combineWithSegmentFinding(ctx, candidate, *exPars, chIds, externalPhiHits);
    }

combineWithSegmentFinding() [2/4]

std::vector< std::unique_ptr< Trk::Track > > Muon::MooTrackBuilder::combineWithSegmentFinding ( const EventContext & ctx, const MuPatTrack & candidate, const Trk::TrackParameters & pars, const std::set< Identifier > & chIds, const PrepVec & patternPhiHits ) const

private

find tracks by redoing the segment finding in the chamber of the segment

Parameters

candidate	a reference to a MuPatTrack
pars	predicted track parameters in first chamber
chIds	identifiers of the chambers in which the search should be performed (should be in same station layer)

Returns

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

Definition at line 539 of file MooTrackBuilder.cxx.

                                                                                                                               {
        std::vector<std::unique_ptr<Trk::Track> > newTracks;
 
        if (chIds.empty()) return newTracks;
 
        if (!m_idHelperSvc->isMdt(*chIds.begin())) {
            ATH_MSG_WARNING("combineWithSegmentFinding called with CSC hits!! retuning zero pointer");
            return newTracks;
        }
 
        // redo segment finding
        std::unique_ptr<Trk::SegmentCollection> segments = m_seededSegmentFinder->find(ctx, pars, chIds);
 
        // check whether we got segments
        if (!segments) {
            ATH_MSG_DEBUG(" failed to find new segments ");
            return newTracks;
        }
        if (segments->empty()) {
            ATH_MSG_DEBUG(" got empty vector!! ");
            return newTracks;
        }
 
        unsigned int nseg = segments->size();
        if (m_useExclusionList) {
            std::vector<const MuonSegment*> referenceSegments;
            for (std::vector<MuPatSegment*>::const_iterator esit = candidate.excludedSegments().begin();
                 esit != candidate.excludedSegments().end(); ++esit) {
                if ((*esit)->segment) referenceSegments.push_back((*esit)->segment);
            }
            removeDuplicateWithReference(segments, referenceSegments);
        }
 
        if (msgLvl(MSG::DEBUG) && segments->size() != nseg) {
            msg(MSG::DEBUG) << MSG::DEBUG
                            << " Rejected segments based on exclusion list, number of removed segments: " << nseg - segments->size()
                            << " total " << segments->size() << endmsg;
        }
 
        if (!segments->empty()) {
            // loop over segments
            for (Trk::Segment* tseg : *segments) {
                if (!tseg) continue;
                MuonSegment* mseg = dynamic_cast<MuonSegment*>(tseg);
 
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " adding segment " << m_printer->print(*mseg);
                    if (msgLvl(MSG::VERBOSE)) {
                        msg(MSG::DEBUG) << std::endl << m_printer->print(mseg->containedMeasurements()) << endmsg;
                        if (msgLvl(MSG::VERBOSE) && candidate.track().measurementsOnTrack())
                            msg(MSG::DEBUG) << " track " << m_printer->print(candidate.track()) << std::endl
                                            << m_printer->print(candidate.track().measurementsOnTrack()->stdcont()) << endmsg;
                    } else {
                        msg(MSG::DEBUG) << endmsg;
                    }
                }
                std::unique_ptr<MuPatSegment> segInfo{m_candidateHandler->createSegInfo(ctx, *mseg)};
 
                if (!m_candidateMatchingTool->match(ctx, candidate, *segInfo, true)) { continue; }
 
                std::unique_ptr<Trk::Track> segTrack = m_fitter->fit(ctx, candidate, *segInfo, externalPhiHits);
 
                if (!segTrack) continue;
 
                ATH_MSG_DEBUG(" found new track " << m_printer->print(*segTrack));
                newTracks.push_back(std::move(segTrack));
            }
        }
 
        if (!newTracks.empty()) ATH_MSG_DEBUG(" found new tracks for segment " << newTracks.size());
 
        return newTracks;
    }

combineWithSegmentFinding() [3/4]

std::vector< std::unique_ptr< Trk::Track > > Muon::MooTrackBuilder::combineWithSegmentFinding ( const EventContext & ctx, const Trk::Track & track, const MuonSegment & seg, const PrepVec & patternPhiHits ) const

private

find tracks by redoing the segment finding in the chamber of the segment

Parameters

track	a reference to a Track
seg	a reference to a MuonSegment

Returns

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

Definition at line 332 of file MooTrackBuilder.cxx.

                                                                                                                               {
 
        // convert segments
        std::unique_ptr<Trk::Track> inTrack = std::make_unique<Trk::Track>(track);
        std::unique_ptr<MuPatTrack> candidate = m_candidateHandler->createCandidate(inTrack);
        if (!candidate) return {};
        std::unique_ptr<MuPatSegment> segInfo(m_candidateHandler->createSegInfo(ctx, seg));
        if (!segInfo) return {};
        // call fit()
        return combineWithSegmentFinding(ctx, *candidate, *segInfo, externalPhiHits);
    }

combineWithSegmentFinding() [4/4]

std::vector< std::unique_ptr< Trk::Track > > Muon::MooTrackBuilder::combineWithSegmentFinding ( const EventContext & ctx, const Trk::Track & track, const Trk::TrackParameters & pars, const std::set< Identifier > & chIds, const PrepVec & patternPhiHits ) const

private

find tracks by redoing the segment finding in the chamber of the segment

Parameters

track	a reference to a Track
pars	predicted track parameters in first chamber
chIds	identifiers of the chambers in which the search should be performed (should be in same station layer)

Returns

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

Definition at line 415 of file MooTrackBuilder.cxx.

                                                                                                                              {
        // convert track
        std::unique_ptr<Trk::Track> inTrack = std::make_unique<Trk::Track>(track);
        std::unique_ptr<MuPatTrack> can = m_candidateHandler->createCandidate(inTrack);
        if (!can) { return {}; }
        return combineWithSegmentFinding(ctx, *can, pars, chIds, patternPhiHits);
    }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

DeclareInterfaceID()

Muon::IMuonSegmentTrackBuilder::DeclareInterfaceID ( Muon::IMuonSegmentTrackBuilder , 1 , 0  )

inherited

access to tool interface

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

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

finalize()

StatusCode Muon::MooTrackBuilder::finalize ( )

overridevirtual

finialize method, method taken from bass-class AlgTool

Definition at line 60 of file MooTrackBuilder.cxx.

                                         {
        if (m_nTimedOut > 0 && m_ncalls > 0) {
            double scale = 1. / m_ncalls;
            ATH_MSG_INFO(" Number of calls that timed out " << m_nTimedOut << " fraction of total calls " << scale * m_nTimedOut);
        }
        return StatusCode::SUCCESS;
    }

find()

std::vector< std::unique_ptr< MuPatTrack > > Muon::MooTrackBuilder::find ( const EventContext & ctx, MuPatCandidateBase & candidate, const std::vector< MuPatSegment * > & segments ) const

overridevirtual

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

Parameters

segments

a vector of input segments in a given chamber layer

Returns

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

Implements Muon::IMuonTrackBuilder.

Definition at line 918 of file MooTrackBuilder.cxx.

                                                                                                                  {
        std::vector<std::unique_ptr<MuPatTrack> > candidates;
        // check whether we have segments
        if (segVec.empty()) return candidates;
 
        std::set<MuPatSegment*> usedSegments;
        std::map<MuPatSegment*, MuPatSegment*> slSegments;
 
        // int looseQualityLevel = 1; // Not used for the moment
        bool tightQualityCuts = false;
        ATH_MSG_DEBUG(" find: " << m_candidateHandler->print(candidate, 0) << std::endl << m_candidateHandler->print(segVec, 0));
 
        // store whether segment was added to at least one candidates
 
        // vector to store candidate extensions
        std::vector<std::pair<MuPatSegment*, std::unique_ptr<Trk::Track> > > extensions;
        extensions.reserve(segVec.size());
 
        // loop over segments
        for (MuPatSegment* seg : segVec) {
            if (usedSegments.count(seg)) continue;
 
            // check whether chamber is already included in candidate
            if (candidate.shareChambers(*seg)) {
                ATH_MSG_VERBOSE("addStationToSeed:: already on candidate " << std::endl << m_printer->print(*seg->segment));
                continue;
            }
 
            if (!m_candidateMatchingTool->match(ctx, candidate, *seg, tightQualityCuts)) {
                ATH_MSG_VERBOSE(" track/segment combination rejected based on angular matching " << std::endl
                                                                                                 << m_printer->print(*seg->segment));
                continue;
            }
 
            ATH_MSG_VERBOSE("combining: " << m_printer->print(*seg->segment));
 
            // try to combine track with segment
            std::unique_ptr<Trk::Track> track = combine(ctx, candidate, *seg, emptyPhiHits);
 
            // additional check in case the candidate is a MuPatTrack
            MuPatTrack* trkCan = dynamic_cast<MuPatTrack*>(&candidate);
            MuPatSegment* segCan = dynamic_cast<MuPatSegment*>(&candidate);
            if (trkCan) {
                if (!track) {
                    trkCan->addExcludedSegment(seg);
                    continue;
                }
 
                // is the new track better
                SortTracksByHitNumber sortTracks;
                if (!sortTracks(*track, trkCan->track())) {
                    ATH_MSG_VERBOSE(" rejecting track as new segment results in worse fit");
                    continue;
                }
 
                // check whether the track cleaner didn't remove one of the already added chamber layers
                // loop over hits
                std::set<MuonStationIndex::StIndex> stationLayersOnTrack;
                for ( const Trk::MeasurementBase* meas : *track->measurementsOnTrack()) {
                    Identifier id = m_edmHelperSvc->getIdentifier(*meas);
                    if (!id.is_valid() || m_idHelperSvc->isTrigger(id)) { continue; }
                    stationLayersOnTrack.insert(m_idHelperSvc->stationIndex(id));
                }
 
                bool hasAllLayers = true;
                for (const MuonStationIndex::StIndex& stIdx :candidate.stations()) {
                    if (!stationLayersOnTrack.count(stIdx)) {
                        ATH_MSG_VERBOSE(" missing layer " << MuonStationIndex::stName(stIdx));
                        hasAllLayers = false;
                    }
                }
 
                if (!hasAllLayers) {
                    ATH_MSG_VERBOSE(" rejecting track as one of the chamber layers of the candidate was removed ");
                    continue;
                }
            }
 
            if (!track) { continue; }
 
            usedSegments.insert(seg);
 
            // now loop over segments once more and try to add SL overlap if missed
            // first check that segment is not an overlap segment
            if (!seg->hasSLOverlap()) {
                std::unique_ptr<MuPatTrack> newCandidate;
                // loop over segments
                for (MuPatSegment* seg_1 : segVec) {
                    // select segments is different chamber
                    if (seg->chIndex == seg_1->chIndex) continue;
 
                    if (!newCandidate) {
                        std::unique_ptr<Trk::Track> trkTrkCan = std::make_unique<Trk::Track>(*track);
                        if (trkCan) {
                            // copy candidate and add segment
                            newCandidate = std::make_unique<MuPatTrack>(*trkCan);
                            m_candidateHandler->extendWithSegment(*newCandidate, *seg, trkTrkCan);
                        } else if (segCan) {
                            newCandidate = m_candidateHandler->createCandidate(*segCan, *seg, trkTrkCan);
                        }
                        if (!newCandidate) break;
                    }
                    if (!m_candidateMatchingTool->match(ctx, *newCandidate, *seg_1, tightQualityCuts)) {
                        ATH_MSG_VERBOSE("track/segment combination rejected based on angular matching "
                                        << std::endl
                                        << m_printer->print(*seg->segment));
                        continue;
                    }
 
                    ATH_MSG_VERBOSE("adding SL overlap " << m_printer->print(*seg_1->segment));
                    std::unique_ptr<Trk::Track> slOverlapTrack = combine(ctx, *track, *seg_1->segment, emptyPhiHits);
                    if (!slOverlapTrack) continue;
 
                    // is the new track better
                    SortTracksByHitNumber sortTracks;
                    if (!sortTracks(*slOverlapTrack, *track)) {
                        ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" rejecting track as new segment results in worse fit");
                        continue;
                    }
                    ATH_MSG_VERBOSE("adding SL overlap ok, new track" << m_printer->print(*slOverlapTrack) << std::endl
                                                                      << m_printer->printStations(*slOverlapTrack));
 
                    track.swap(slOverlapTrack);
                    usedSegments.insert(seg_1);
                    slSegments[seg] = seg_1;
                    break;
                }
            }
 
            ATH_MSG_VERBOSE(" Track found " << m_printer->print(*track)<<std::endl<<m_printer->printMeasurements(*track));
 
            // add new solution
            extensions.emplace_back(seg, std::move(track));
 
        }  // for (sit)
 
        // loop over solutions and add them
        if (!extensions.empty()) {
            candidates.reserve(extensions.size());
 
            // additional check in case the candidate is a MuPatTrack
            MuPatTrack* trkCan = dynamic_cast<MuPatTrack*>(&candidate);
            MuPatSegment* segCan = dynamic_cast<MuPatSegment*>(&candidate);
 
            // if more than 1 extensions are found, first add the copies
            // start from the second one to make copies based on the existing candidates
            for (std::pair<MuPatSegment*, std::unique_ptr<Trk::Track> >& ext_itr : extensions) {
                std::unique_ptr<MuPatTrack> newCandidate;
                if (trkCan) {
                    // copy candidate and add segment
                    newCandidate = std::make_unique<MuPatTrack>(*trkCan);
                    m_candidateHandler->extendWithSegment(*newCandidate, *ext_itr.first, ext_itr.second);
                } else if (segCan) {
                    newCandidate = m_candidateHandler->createCandidate(*segCan, *ext_itr.first, ext_itr.second);
                }
                ATH_MSG_DEBUG(" " << m_printer->print(*ext_itr.first->segment));
                MuPatSegment* slOverlap = slSegments[ext_itr.first];
 
                if (slOverlap) {
                    ATH_MSG_DEBUG("SLOverlap " << m_printer->print(*slOverlap->segment));
                    // hack to allow me to add a second segment without changing the track
                    std::unique_ptr<Trk::Track> nullTrack;
                    newCandidate->addSegment(slOverlap, nullTrack);
                }
                candidates.push_back(std::move(newCandidate));
 
                ATH_MSG_DEBUG(" creating new candidate " << candidates.back().get() << std::endl
                                                         << m_printer->print(candidates.back()->track()) << std::endl
                                                         << m_printer->printStations(candidates.back()->track()));
            }
        }
        return candidates;
    }

findClosestParameters()

std::unique_ptr< Trk::TrackParameters > Muon::MooTrackBuilder::findClosestParameters ( const Trk::Track & track, const Amg::Vector3D & pos ) const

overridevirtual

find closest TrackParameters to the position.

Closest is defined as closest in z in the endcap and closest in r in the barrel.

Parameters

track	a reference to a Track
pos	a reference to a GlobalPosition

Returns

a pointer to TrackParameters, the ownership of the parameters is passed to the client calling the tool.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 345 of file MooTrackBuilder.cxx.

                                                                                                                                {
        // are we in the endcap?
        bool isEndcap = m_edmHelperSvc->isEndcap(track);
 
        // position of segment
        double posSeg = isEndcap ? pos.z() : pos.perp();
 
        // position closest parameters
        double closest = 1e8;
        const Trk::TrackParameters* closestParameters = nullptr;
        bool closestIsMeasured = false;
 
        // loop over track and calculate residuals
        const Trk::TrackStates* states = track.trackStateOnSurfaces();
        if (!states) {
            ATH_MSG_DEBUG(" track without states! ");
            return nullptr;
        }
 
        // loop over TSOSs
        Trk::TrackStates::const_iterator tsit = states->begin();
        Trk::TrackStates::const_iterator tsit_end = states->end();
        for (; tsit != tsit_end; ++tsit) {
            // check whether state is a measurement
            const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
            if (!meas) { continue; }
 
            const Trk::TrackParameters* pars = (*tsit)->trackParameters();
            if (!pars) { continue; }
 
            // check whether measured parameters
            bool isMeasured = pars->covariance();
 
            // skip all none measured TrackParameters as soon as we found one with a measurement
            if (closestIsMeasured && !isMeasured) continue;
 
            // calculate position parameters and compare with position segment
            double posPars = isEndcap ? pars->position().z() : pars->position().perp();
            double diffPos = std::abs(posPars - posSeg);
 
            // accept if measured parameters or the current accepted parameters are not yet measured
            if ((isMeasured && !closestIsMeasured) || diffPos < closest) {
                closest = diffPos;
                closestParameters = pars;
                closestIsMeasured = isMeasured;
 
                // if we are within 100 mm take current
                if (closest < 100.) { break; }
            }
        }
 
        // return clone of parameters
        if (closestParameters) return closestParameters->uniqueClone();
        return nullptr;
    }

getClosestParameters() [1/2]

std::unique_ptr< Trk::TrackParameters > Muon::MooTrackBuilder::getClosestParameters	(	const MuPatCandidateBase &	candidate,
		const Trk::Surface &	surf ) const

find closest TrackParameters to the surface.

The distance is calculated along the track

Parameters

track	a reference to a MuPatCandidateBase
pos	a reference to a Surface

Returns

a pointer to TrackParameters, the ownership of the parameters is passed to the client calling the tool.

Definition at line 401 of file MooTrackBuilder.cxx.

                                                                                                                                             {
        // cast to segment, return segment parameters if cast success
        const MuPatSegment* segCandidate = dynamic_cast<const MuPatSegment*>(&candidate);
        if (segCandidate) return segCandidate->entryPars().uniqueClone();
 
        // for a track candidate, return the closest parameter on the track
        const MuPatTrack& trkCandidate = dynamic_cast<const MuPatTrack&>(candidate);
        return getClosestParameters(trkCandidate.track(), surf);
    }

getClosestParameters() [2/2]

std::unique_ptr< Trk::TrackParameters > Muon::MooTrackBuilder::getClosestParameters ( const Trk::Track & track, const Trk::Surface & surf ) const

overridevirtual

find closest TrackParameters to the surface.

The distance is calculated along the track

Parameters

track	a reference to a Track
pos	a reference to a Surface

Returns

a pointer to TrackParameters, the ownership of the parameters is passed to the client calling the tool.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 411 of file MooTrackBuilder.cxx.

                                                                                                                               {
        return MuonGetClosestParameters::closestParameters(track, surf);
    }

initialize()

StatusCode Muon::MooTrackBuilder::initialize ( )

overridevirtual

initialize method, method taken from bass-class AlgTool

Definition at line 37 of file MooTrackBuilder.cxx.

                                           {
        ATH_CHECK(m_fitter.retrieve());
        ATH_CHECK(m_slFitter.retrieve());
        ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
        ATH_CHECK(m_errorOptimisationTool.retrieve(DisableTool{m_errorOptimisationTool.empty()}));
        ATH_CHECK(m_candidateHandler.retrieve());
        ATH_CHECK(m_candidateMatchingTool.retrieve());
        ATH_CHECK(m_muonChamberHoleRecoverTool.retrieve());
        ATH_CHECK(m_trackExtrapolationTool.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_trackToSegmentTool.retrieve());
        ATH_CHECK(m_seededSegmentFinder.retrieve());
        ATH_CHECK(m_mdtRotCreator.retrieve());
        ATH_CHECK(m_compRotCreator.retrieve());
        ATH_CHECK(m_propagator.retrieve());
        ATH_CHECK(m_pullCalculator.retrieve());
        ATH_CHECK(m_trackSummaryTool.retrieve());
 
        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.

insertClustersWithCompetingRotCreation()

Trk::TrackStates::const_iterator Muon::MooTrackBuilder::insertClustersWithCompetingRotCreation ( const EventContext & ctx, Trk::TrackStates::const_iterator tsit, Trk::TrackStates::const_iterator tsit_end, std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > & states ) const

private

Definition at line 722 of file MooTrackBuilder.cxx.

                                                                               {
        // iterator should point to a valid element
        if (tsit == tsit_end) {
            ATH_MSG_WARNING(" iterator pointing to end of vector, this should no happen ");
            return --tsit;
        }
 
        // check whether state is a measurement
        const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
        const Trk::TrackParameters* pars = (*tsit)->trackParameters();
        if (!meas || !pars) {
            ATH_MSG_WARNING(" iterator pointing to a TSOS without a measurement or TrackParameters ");
            if (tsit + 1 == tsit_end) --tsit;
            return tsit;
        }
 
        ATH_MSG_VERBOSE(" inserting with competing ROT creation ");
 
        // loop over states until we reached the last tgc hit in this detector element
        // keep trackof the identifiers and the states
        std::list<const Trk::PrepRawData*> etaPrds;
        std::list<const Trk::PrepRawData*> phiPrds;
        const Trk::TrkDetElementBase* currentDetEl = nullptr;
        std::vector<std::unique_ptr<const Trk::TrackStateOnSurface> > newStates;
        // keep track of outliers as we might have to drop them..
        std::vector<std::pair<bool, const Trk::TrackStateOnSurface*> > outlierStates;
        bool hasPhi {false}, hasEta{false};
 
        for (; tsit != tsit_end; ++tsit) {
            const Trk::TrackStateOnSurface* in_tsos = *tsit;
            if (!in_tsos) continue;
 
            // check whether state is a measurement, keep if not
            const Trk::MeasurementBase* meas = in_tsos->measurementOnTrack();
            if (!meas) {
                newStates.emplace_back(in_tsos->clone());
                continue;
            }
 
            // get identifier, keep state if it has no identifier.
            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
            if (!id.is_valid()) {
                newStates.emplace_back(in_tsos->clone());
                continue;
            }
 
            // sanity check, this SHOULD be a RPC, TGC or CSC measurement
            if (!(m_idHelperSvc->isTrigger(id))) { break; }
 
            bool measuresPhi = m_idHelperSvc->measuresPhi(id);
            if (!hasPhi && measuresPhi) hasPhi = true;
            if (!hasEta && !measuresPhi) hasEta = true;
 
            // check whether state is a measurement
            if ((*tsit)->type(Trk::TrackStateOnSurface::Outlier)) {
                outlierStates.emplace_back(measuresPhi, in_tsos);
                continue;
            }
 
            // check whether we are still in the same chamber, stop loop if not
 
            ATH_MSG_VERBOSE(" handling " << m_idHelperSvc->toString(id));
 
            std::list<const Trk::PrepRawData*>& prdList = measuresPhi ? phiPrds : etaPrds;
            const MuonClusterOnTrack* clus = dynamic_cast<const MuonClusterOnTrack*>(meas);
            if (clus) {
                const Trk::TrkDetElementBase* detEl = clus->detectorElement();
                if (!currentDetEl) currentDetEl = detEl;
                if (detEl != currentDetEl) {
                    ATH_MSG_VERBOSE(" new detector element stopping ");
                    break;
                }
                prdList.push_back(clus->prepRawData());
            } else {
                // split competing ROTs into constituents
                const CompetingMuonClustersOnTrack* comp = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
                if (comp) {
                    const Trk::TrkDetElementBase* detEl = nullptr;
                    if (comp->containedROTs().empty()) {
                        ATH_MSG_WARNING(" CompetingROT without constituents ");
                        break;
                    }
                    detEl = comp->containedROTs().front()->detectorElement();
                    if (!currentDetEl) currentDetEl = detEl;
                    if (detEl != currentDetEl) {
                        ATH_MSG_VERBOSE(" new detector element stopping ");
                        break;
                    }
                    std::vector<const MuonClusterOnTrack*>::const_iterator clit = comp->containedROTs().begin();
                    std::vector<const MuonClusterOnTrack*>::const_iterator clit_end = comp->containedROTs().end();
                    for (; clit != clit_end; ++clit) { prdList.push_back((*clit)->prepRawData()); }
 
                } else {
                    ATH_MSG_WARNING(" Unknown trigger hit type! ");
                    continue;
                }
            }
        }
 
        // now that we have the lists of prds we can create the competing rots
        if (!etaPrds.empty()) {
            std::unique_ptr<CompetingMuonClustersOnTrack> etaCompRot = m_compRotCreator->createBroadCluster(etaPrds, 0.);
            if (!etaCompRot) {
                ATH_MSG_WARNING(" Failed to create CompetingMuonClustersOnTrack for eta hits! ");
            } else {
                std::unique_ptr<Trk::TrackParameters> etaPars;;
                // check whether original parameters are on surface, if so clone original parameters
                if (etaCompRot->associatedSurface() == pars->associatedSurface()) {
                    etaPars = pars->uniqueClone();
                } else {
                    // ownership relinquished, should be treated in createMeasTSOS
                    etaPars =
                        m_propagator->propagate(ctx,*pars,
                          etaCompRot->associatedSurface(),
                          Trk::anyDirection, false, m_magFieldProperties);
                }
                if (!etaPars) {
                    ATH_MSG_WARNING(" Failed to calculate TrackParameters for eta hits! ");
                } else {
                    std::unique_ptr<Trk::TrackStateOnSurface> tsos =
                        MuonTSOSHelper::createMeasTSOS(std::move(etaCompRot), std::move(etaPars), Trk::TrackStateOnSurface::Measurement);
                    newStates.push_back(std::move(tsos));
                }
            }
        }
 
        if (!phiPrds.empty()) {
            std::unique_ptr<CompetingMuonClustersOnTrack> phiCompRot = m_compRotCreator->createBroadCluster(phiPrds, 0.);
            if (!phiCompRot) {
                ATH_MSG_WARNING(" Failed to create CompetingMuonClustersOnTrack for phi hits! ");
            } else {
                std::unique_ptr<Trk::TrackParameters> phiPars;
                // check whether original parameters are on surface, if so clone original parameters
                if (phiCompRot->associatedSurface() == pars->associatedSurface()) {
                    phiPars = pars->uniqueClone();
                } else {
                    // ownership relinquished, handled in createMeasTSOS
                    phiPars =
                        m_propagator->propagate(ctx, *pars, phiCompRot->associatedSurface(),
                        Trk::anyDirection, false, m_magFieldProperties);
                }
                if (!phiPars) {
                    ATH_MSG_WARNING(" Failed to calculate TrackParameters for phi hits! ");
                } else {
                    std::unique_ptr<Trk::TrackStateOnSurface> tsos =
                        MuonTSOSHelper::createMeasTSOS(std::move(phiCompRot), std::move(phiPars), Trk::TrackStateOnSurface::Measurement);
                    newStates.push_back(std::move(tsos));
                }
            }
        }
 
        // add outliers if there was no measurement on track in the same projection
        for (const auto& outlier : outlierStates) {
            if (hasPhi && outlier.first)
                newStates.emplace_back(outlier.second->clone());
            else if (hasEta && !outlier.first)
                newStates.emplace_back(outlier.second->clone());
            else if (msgLvl(MSG::DEBUG))
                msg(MSG::DEBUG) << " Dropping outlier " << endmsg;
        }
 
        // sort all states in this chamber
        std::stable_sort(newStates.begin(), newStates.end(), SortTSOSByDistanceToPars(pars));
 
        // insert the states into
        states.insert(states.end(), std::make_move_iterator(newStates.begin()),
                                    std::make_move_iterator(newStates.end()));
 
        // iterator should point to the last TGC in this chamber
        return --tsit;
    }

interfaceID()

const InterfaceID & Muon::MooTrackBuilder::interfaceID ( )

inlinestatic

access to tool interface

Definition at line 99 of file MooTrackBuilder.h.

                                                {
            static const InterfaceID IID_MooTrackBuilder("Muon::MooTrackBuilder", 1, 0);
            return IID_MooTrackBuilder;
        }

isSplitTrack()

bool Muon::MooTrackBuilder::isSplitTrack ( const EventContext & ctx, const Trk::Track & track1, const Trk::Track & track2 ) const

private

identify whether two track are split

Definition at line 1093 of file MooTrackBuilder.cxx.

                                                                                                                    {
        // some loose association cuts
        const DataVector<const Trk::TrackParameters>* parsVec1 = track1.trackParameters();
        if (!parsVec1 || parsVec1->empty()) {
            ATH_MSG_WARNING(" isSplitTrack::Track without parameters! ");
            return false;
        }
        const Trk::TrackParameters* pars1 = parsVec1->front();
        if (!pars1) {
            ATH_MSG_WARNING(" isSplitTrack::Track without NULL pointer in parameter vector! ");
            return false;
        }
 
        const DataVector<const Trk::TrackParameters>* parsVec2 = track2.trackParameters();
        if (!parsVec2 || parsVec2->empty()) {
            ATH_MSG_WARNING(" isSplitTrack::Track without parameters! ");
            return false;
        }
        const Trk::TrackParameters* pars2 = parsVec2->front();
        if (!pars2) {
            ATH_MSG_WARNING(" isSplitTrack::Track without NULL pointer in parameter vector! ");
            return false;
        }
 
        if (!m_candidateMatchingTool->sameSide(pars1->momentum().unit(), pars1->position(), pars2->position(), true)) {
            ATH_MSG_DEBUG(" tracks in opposite hemispheres ");
            return false;
        }
 
        double sinTheta1 = sin(pars1->momentum().theta());
        double sinTheta2 = sin(pars2->momentum().theta());
        double deltaSinTheta = sinTheta1 - sinTheta2;
        if (std::abs(deltaSinTheta) > 1.) {
            ATH_MSG_DEBUG(" too large opening angle in theta " << deltaSinTheta);
            // return false;
        }
        double sinPhi1 = sin(pars1->momentum().phi());
        double sinPhi2 = sin(pars2->momentum().phi());
        double deltaSinPhi = sinPhi1 - sinPhi2;
        if (std::abs(deltaSinPhi) > 1.) {
            ATH_MSG_DEBUG(" too large opening angle in phi " << deltaSinPhi);
            // return false;
        }
 
        const Trk::Track* referenceTrack = nullptr;
        const Trk::Track* otherTrack = nullptr;
 
        // first check whether the tracks have a momentum measurement
        bool isSL1 = m_edmHelperSvc->isSLTrack(track1);
        bool isSL2 = m_edmHelperSvc->isSLTrack(track2);
 
        // now decide which track to use as reference
        if (isSL1 && !isSL2) {
            referenceTrack = &track2;
            otherTrack = &track1;
        } else if (!isSL1 && isSL2) {
            referenceTrack = &track1;
            otherTrack = &track2;
        } else {
            SortTracksByHitNumber sortTracks;
            bool pickFirst = sortTracks(track1, track2);
            if (pickFirst) {
                referenceTrack = &track1;
                otherTrack = &track2;
            } else {
                referenceTrack = &track2;
                otherTrack = &track1;
            }
        }
 
        ATH_MSG_DEBUG(" close tracks " << std::endl << m_printer->print(*referenceTrack) << std::endl << m_printer->print(*otherTrack));
 
        // get iterators to TSOSs
        const Trk::TrackStates* statesRef = referenceTrack->trackStateOnSurfaces();
        if (!statesRef) {
            ATH_MSG_WARNING(" track without states, cannot perform cleaning ");
            return false;
        }
        Trk::TrackStates::const_iterator refTSOS = statesRef->begin();
        Trk::TrackStates::const_iterator refTSOS_end = statesRef->end();
 
        const Trk::TrackStates* statesOther = otherTrack->trackStateOnSurfaces();
        if (!statesOther) {
            ATH_MSG_WARNING(" track without states, cannot perform cleaning ");
            return false;
        }
        Trk::TrackStates::const_iterator otherTSOS = statesOther->begin();
        Trk::TrackStates::const_iterator otherTSOS_end = statesOther->end();
 
        DistanceAlongParameters distAlongPars;
 
        unsigned int nmatching(0);
        unsigned int noff(0);
 
        // keep track of previous distance and parameters as well
        double prevDist = 1e10;
        const Trk::TrackParameters* prevPars = nullptr;
 
        // now loop over the TSOSs of both tracks and compare hit by hit
        while (refTSOS != refTSOS_end && otherTSOS != otherTSOS_end) {
            const Trk::TrackParameters* parsRef = (*refTSOS)->trackParameters();
            if (!parsRef) {
                ++refTSOS;
                continue;
            }
 
            const Trk::TrackParameters* parsOther = (*otherTSOS)->trackParameters();
            if (!parsOther) {
                ++otherTSOS;
                continue;
            }
 
            double dist = distAlongPars(*parsRef, *parsOther);
 
            if (dist > 0.) {
                prevDist = dist;
                prevPars = parsRef;
                ++refTSOS;
                continue;
            } else {
                const Trk::TrackParameters* closestPars = nullptr;
                if (prevPars && std::abs(prevDist) < std::abs(dist)) {
                    closestPars = prevPars;
                } else {
                    closestPars = parsRef;
                }
 
                // check whether state is a measurement
                const Trk::MeasurementBase* meas = (*otherTSOS)->measurementOnTrack();
                if (meas && (*otherTSOS)->type(Trk::TrackStateOnSurface::Measurement)) {
                    Identifier id = m_edmHelperSvc->getIdentifier(*meas);
                    // skip pseudo measurements
                    if (!id.is_valid()) {
                        prevDist = dist;
                        prevPars = parsRef;
                        ++otherTSOS;
                        continue;
                    }
                    if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << m_idHelperSvc->toString(id);
                    // unique ptr ownership retained. Original code deleted impactPars
                    auto impactPars =
                        m_propagator->propagate(ctx, *closestPars, meas->associatedSurface(),
                                                Trk::anyDirection, false, m_magFieldProperties);
                    if (impactPars) {
                        double residual = 1e10;
                        double pull = 1e10;
                        // pointer to resPull
                        std::optional<Trk::ResidualPull> resPull =
                            m_pullCalculator->residualPull(meas, impactPars.get(), Trk::ResidualPull::Unbiased);
                        if (resPull && resPull->pull().size() == 1) {
                            if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "  residual " << m_printer->print(*resPull);
                            residual = resPull->residual().front();
                            pull = resPull->pull().front();
                        } else {
                            ATH_MSG_WARNING("failed to calculate residual and pull");
                        }
 
                        bool inBounds = false;
                        Amg::Vector2D LocVec2D;
                        bool ok = meas->associatedSurface().globalToLocal(impactPars->position(), impactPars->momentum(), LocVec2D);
                        // delete impactPars;
                        if (ok) {
                            if (msgLvl(MSG::VERBOSE))
                                msg(MSG::VERBOSE) << "  lpos (" << LocVec2D[Trk::locX] << "," << LocVec2D[Trk::locY] << ")";
                            double tol1 = 50.;
                            double tol2 = tol1;
                            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
                            if (msgLvl(MSG::VERBOSE) && m_idHelperSvc->isMdt(id)) {
                                const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
                                if (mdt) {
                                    int layer = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
                                    int tube = m_idHelperSvc->mdtIdHelper().tube(id);
                                    double halfTubeLen = 0.5 * mdt->detectorElement()->getActiveTubeLength(layer, tube);
                                    if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "  range " << halfTubeLen;
                                }
                            }
 
                            // for MM, perform the bound check from the detector element to take into account edge passivation
                            const MMClusterOnTrack* mmClusterOnTrack = dynamic_cast<const MMClusterOnTrack*>(meas);
                            if (mmClusterOnTrack) {
                                inBounds = mmClusterOnTrack->detectorElement()->insideActiveBounds(id, LocVec2D, tol1, tol2);
                            } else {
                                inBounds = meas->associatedSurface().insideBounds(LocVec2D, tol1, tol2);
                            }
 
                            if (msgLvl(MSG::VERBOSE)) {
                                if (inBounds)
                                    msg(MSG::VERBOSE) << " inBounds ";
                                else
                                    msg(MSG::VERBOSE) << " outBounds ";
                            }
                        } else {
                            ATH_MSG_WARNING("globalToLocal failed");
                        }
 
                        if (inBounds && (std::abs(residual) < 20. || std::abs(pull) < 10.)) {
                            ATH_MSG_VERBOSE(" --> matching ");
                            ++nmatching;
                        } else {
                            ATH_MSG_VERBOSE(" --> off ");
                            ++noff;
                        }
 
                    } else {
                        ATH_MSG_DEBUG("failed to extrapolate parameters to surface");
                    }
                }
 
                prevDist = dist;
                prevPars = parsRef;
                ++otherTSOS;
                continue;
            }
        }
 
        // if more hits are compatible with reference track than are not consider as split track
        return nmatching > noff;
    }

mergeSplitTracks()

TrackCollection * Muon::MooTrackBuilder::mergeSplitTracks ( const EventContext & ctx, const TrackCollection & tracks ) const

private

look for split tracks in collection and merge them

Definition at line 1312 of file MooTrackBuilder.cxx.

                                                                                                                   {
        // vector to store good track, boolean is used to identify whether the track was created in this routine or is from the collection
        std::vector<std::pair<bool, std::unique_ptr<Trk::Track> > > goodTracks;
        goodTracks.reserve(tracks.size());
        bool foundSplitTracks = false;
 
        ATH_MSG_DEBUG(" trying to merge split tracks, collection size " << tracks.size());
 
        // loop over tracks
        for (const Trk::Track* in_track : tracks) {
            // pointer to merged track
            std::unique_ptr<Trk::Track> mergedTrack;
 
            // compare them to all good tracks and look for split tracks
            for (std::pair<bool, std::unique_ptr<Trk::Track>>& good_trk : goodTracks) {
                // check whether track is split
                bool isSplit = isSplitTrack(ctx, *good_trk.second, *in_track);
                if (isSplit) {
                    // if we found a potential split track, try to combine them
                    std::unique_ptr<Trk::Track> track1 = std::make_unique<Trk::Track>(*good_trk.second);
                    std::unique_ptr<Trk::Track> track2 = std::make_unique<Trk::Track>(*in_track);
                    std::unique_ptr<MuPatTrack> can1 = m_candidateHandler->createCandidate(track1);
                    std::unique_ptr<MuPatTrack> can2 = m_candidateHandler->createCandidate(track2);
                    mergedTrack = combine(ctx, *can1, *can2, emptyPhiHits);
 
                    // we have found a split track and have successfully merged it
                    // replace the track in goodTracks with the new one
                    if (mergedTrack) {
                        ATH_MSG_DEBUG(" origninal tracks " << std::endl
                                                           << m_printer->print(*good_trk.second) << std::endl
                                                           << m_printer->printStations(*good_trk.second) << std::endl
                                                           << m_printer->print(*in_track) << std::endl
                                                           << m_printer->printStations(*in_track) << std::endl
                                                           << " merged track " << std::endl
                                                           << m_printer->print(*mergedTrack) << std::endl
                                                           << m_printer->printStations(*mergedTrack));
                        foundSplitTracks = true;
                        // check whether this is a new track, if so delete the old one before overwriting it
                        good_trk.first = true;
                        good_trk.second.swap(mergedTrack);
                        break;
                    } else {
                        ATH_MSG_VERBOSE(" failed to merge tracks " << std::endl
                                                                   << m_printer->print(*good_trk.second) << std::endl
                                                                   << m_printer->printStations(*good_trk.second) << std::endl
                                                                   << m_printer->print(*in_track) << std::endl
                                                                   << m_printer->printStations(*in_track));
                    }
                }
            }
 
            // if this track was not merged with another track insert it into goodTracks
            if (!mergedTrack) {
                std::unique_ptr<Trk::Track> newTrack = std::make_unique<Trk::Track>(*in_track);
                goodTracks.emplace_back(false, std::move(newTrack));
            }
        }
 
        // did we find any?
        if (!foundSplitTracks) return nullptr;
        // loop over the new track vector and create a new TrackCollection
        TrackCollection* newTracks = new TrackCollection();
        newTracks->reserve(goodTracks.size());
        for (std::pair<bool, std::unique_ptr<Trk::Track>>& good_trk: goodTracks) {
            // TrackCollection will take ownership
            newTracks->push_back(std::move(good_trk.second));
        }
        return newTracks;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

recalibrateHitsOnTrack()

std::unique_ptr< Trk::Track > Muon::MooTrackBuilder::recalibrateHitsOnTrack ( const EventContext & ctx, const Trk::Track & track, bool doMdts, bool doCompetingClusters ) const

overridevirtual

recalibrate hits on track

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 616 of file MooTrackBuilder.cxx.

                                                                                                        {
        // loop over track and calculate residuals
        const Trk::TrackStates* states = track.trackStateOnSurfaces();
        if (!states) {
            ATH_MSG_DEBUG(" track without states, discarding track ");
            return nullptr;
        }
        if (msgLvl(MSG::DEBUG)) {
            msg(MSG::DEBUG) << MSG::DEBUG << " recalibrating hits on track " << std::endl << m_printer->print(track);
 
            if (msgLvl(MSG::VERBOSE)) {
                if (track.measurementsOnTrack())
                    msg(MSG::DEBUG) << std::endl << m_printer->print(track.measurementsOnTrack()->stdcont()) << endmsg;
            } else {
                msg(MSG::DEBUG) << endmsg;
            }
        }
        // vector to store states, the boolean indicated whether the state was create in this routine (true) or belongs to the track (false)
        // If any new state is created, all states will be cloned and a new track will beformed from them.
        std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> newStates;
        newStates.reserve(states->size() + 5);
 
        // loop over TSOSs
        Trk::TrackStates::const_iterator state_itr = states->begin();
        Trk::TrackStates::const_iterator end_itr = states->end();
        for (; state_itr != end_itr; ++state_itr) {
            const Trk::TrackStateOnSurface* tsit = (*state_itr);
            if (!tsit) continue;  // sanity check
 
            // check whether state is a measurement
            const Trk::TrackParameters* pars = tsit->trackParameters();
            if (!pars) {
                newStates.emplace_back(tsit->clone());
                continue;
            }
 
            // check whether state is a measurement
            const Trk::MeasurementBase* meas = tsit->measurementOnTrack();
            if (!meas) {
                newStates.emplace_back(tsit->clone());
                continue;
            }
 
            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
 
            // Not a ROT, else it would have had an identifier. Keep the TSOS.
            if (!id.is_valid() || !m_idHelperSvc->isMuon(id)) {
                newStates.emplace_back(tsit->clone());
                continue;
            }
 
            ATH_MSG_VERBOSE(" new measurement " << m_idHelperSvc->toString(id));
 
            if (m_idHelperSvc->isMdt(id)) {
                if (doMdts) {
                    const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
                    if (!mdt) {
                        ATH_MSG_WARNING(" Measurement with MDT identifier that is not a MdtDriftCircleOnTrack ");
                        continue;
                    }
                    std::unique_ptr<Trk::RIO_OnTrack> newMdt(m_mdtRotCreator->correct(*mdt->prepRawData(), *pars, ctx));
                    if (!newMdt) {
                        ATH_MSG_WARNING(" Failed to recalibrate MDT ");
                        continue;
                    }
                    std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createMeasTSOSWithUpdate(
                        *tsit, std::move(newMdt), pars->uniqueClone(),
                         tsit->type(Trk::TrackStateOnSurface::Outlier) ? Trk::TrackStateOnSurface::Outlier
                                                                         : Trk::TrackStateOnSurface::Measurement);
                    newStates.push_back(std::move(tsos));
 
                } else {
                    newStates.emplace_back(tsit->clone());
                }
 
            } else if (m_idHelperSvc->isCsc(id)) {
                newStates.emplace_back(tsit->clone());
 
            } else if (m_idHelperSvc->isTrigger(id)) {
                if (doCompetingClusters) {
                    state_itr = insertClustersWithCompetingRotCreation(ctx, state_itr, end_itr, newStates);
                } else {
                    newStates.emplace_back(tsit->clone());
                }
 
            } else if (m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id)) {
                newStates.emplace_back(tsit->clone());
            } else {
                ATH_MSG_WARNING(" unknown Identifier ");
            }
        }
 
        ATH_MSG_DEBUG(" original track had " << states->size() << " TSOS, adding " << newStates.size() - states->size() << " new TSOS ");
 
        // states were added, create a new track
        auto trackStateOnSurfaces = std::make_unique<Trk::TrackStates>();
        trackStateOnSurfaces->reserve(newStates.size());
        for (std::unique_ptr<const Trk::TrackStateOnSurface>& new_state : newStates) {
            // add states. If nit->first is true we have a new state. If it is false the state is from the old track and has to be cloned
            trackStateOnSurfaces->push_back(std::move(new_state));
        }
        return std::make_unique<Trk::Track>(track.info(), std::move(trackStateOnSurfaces),
                                            track.fitQuality() ? track.fitQuality()->uniqueClone() : nullptr);
    }

refine()

void Muon::MooTrackBuilder::refine ( const EventContext & ctx, MuPatTrack & track ) const

overridevirtual

interface for tools which refine the hit content of a given track

Parameters

track

input track

Returns

new refined track. Pointer could be zero, ownership passed to caller

Implements Muon::IMuonTrackRefiner.

Definition at line 92 of file MooTrackBuilder.cxx.

                                                                                 {
 
        ATH_MSG_VERBOSE("refine: before recovery " << std::endl
                                                  << m_printer->print(track.track()) << std::endl
                                                  << m_printer->print(track.track().measurementsOnTrack()->stdcont()));
 
        std::unique_ptr<Trk::Track> finalTrack(m_muonChamberHoleRecoverTool->recover(track.track(), ctx));
        if (!finalTrack) { ATH_MSG_WARNING(" final track lost, this should not happen "); }
        ATH_MSG_VERBOSE("refine: after recovery " << std::endl
                                                  << m_printer->print(*finalTrack) << std::endl
                                                  << m_printer->print(finalTrack->measurementsOnTrack()->stdcont()));
 
        // generate a track summary for this track
        if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*finalTrack, false); }
 
        bool recalibrateMDTHits = m_recalibrateMDTHits;
        bool recreateCompetingROTs = true;
        std::unique_ptr<Trk::Track> recalibratedTrack = recalibrateHitsOnTrack(ctx, *finalTrack, recalibrateMDTHits, recreateCompetingROTs);
        if (!recalibratedTrack) {
            ATH_MSG_WARNING(" failed to recalibrate hits on track " << std::endl << m_printer->print(*finalTrack));
        } else
            finalTrack.swap(recalibratedTrack);
 
        std::unique_ptr<Trk::Track> refittedTrack = refit(ctx, *finalTrack);
        if (!refittedTrack) {
            ATH_MSG_VERBOSE(" failed to refit track " << std::endl
                                                      << m_printer->print(*finalTrack) << std::endl
                                                      << m_printer->printStations(*finalTrack));
        } else
            finalTrack.swap(refittedTrack);
 
        // redo holes as they are dropped in the fitter
        std::unique_ptr<Trk::Track> finalTrackWithHoles(m_muonChamberHoleRecoverTool->recover(*finalTrack, ctx));
        if (!finalTrackWithHoles) {
            ATH_MSG_WARNING(" failed to add holes to final track, this should not happen ");
        } else
            finalTrack.swap(finalTrackWithHoles);
 
        std::unique_ptr<Trk::Track> entryRecordTrack(m_trackExtrapolationTool->extrapolate(*finalTrack, ctx));
        if (entryRecordTrack) {
            finalTrack.swap(entryRecordTrack);
            ATH_MSG_VERBOSE(" track at muon entry record " << std::endl << m_printer->print(*finalTrack));
        }
        m_candidateHandler->updateTrack(track, finalTrack);
    }

refit()

std::unique_ptr< Trk::Track > Muon::MooTrackBuilder::refit ( const EventContext & ctx, Trk::Track & track ) const

overridevirtual

refit track

Parameters

track

the track

Returns

a pointer to the resulting track, will return zero if combination failed. Ownership passed to user.

Implements Muon::IMuonSegmentTrackBuilder.

Definition at line 68 of file MooTrackBuilder.cxx.

                                                                                                 {
        // use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
 
        if (m_edmHelperSvc->isSLTrack(track)) return m_slFitter->refit(ctx, track);
 
        // Also check if toriod is off:
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
        const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
        if (!fieldCondObj) {
            ATH_MSG_ERROR("refit: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return nullptr;
        }
        fieldCondObj->getInitializedCache(fieldCache);
        if (!fieldCache.toroidOn()) return m_slFitter->refit(ctx, track);
 
        // if not refit tool specified do a pure refit
        if (m_errorOptimisationTool.empty()) return m_fitter->refit(ctx, track);
        std::unique_ptr<Trk::Track> optTrack = m_errorOptimisationTool->optimiseErrors(track, ctx);
        return optTrack;
    }

removeDuplicateWithReference()

void Muon::MooTrackBuilder::removeDuplicateWithReference ( std::unique_ptr< Trk::SegmentCollection > & segments, std::vector< const MuonSegment * > & referenceSegments ) const

private

Definition at line 482 of file MooTrackBuilder.cxx.

                                                                                                               {
        if (referenceSegments.empty()) return;
 
        ATH_MSG_DEBUG(" Removing duplicates from segment vector of size " << segments->size() << " reference size "
                                                                          << referenceSegments.size());
 
        CompareMuonSegmentKeys compareSegmentKeys{};
 
        // create a vector with pairs of MuonSegmentKey and a pointer to the corresponding segment to resolve ambiguities
        std::vector<std::pair<MuonSegmentKey, Trk::SegmentCollection::iterator> > segKeys;
        segKeys.reserve(segments->size());
 
        // loop over reference segments and make keys
        Trk::SegmentCollection::iterator sit = segments->begin();
        Trk::SegmentCollection::iterator sit_end = segments->end();
        for (; sit != sit_end; ++sit) {
            Trk::Segment* tseg = *sit;
            MuonSegment* mseg = dynamic_cast<MuonSegment*>(tseg);
            segKeys.emplace_back(MuonSegmentKey(*mseg), sit);
        }
 
        // create a vector with pairs of MuonSegmentKey and a pointer to the corresponding segment to resolve ambiguities
        std::vector<MuonSegmentKey> referenceSegKeys;
        referenceSegKeys.reserve(referenceSegments.size());
 
        // loop over reference segments and make keys
        std::vector<const MuonSegment*>::iterator vit = referenceSegments.begin();
        std::vector<const MuonSegment*>::iterator vit_end = referenceSegments.end();
        for (; vit != vit_end; ++vit) { referenceSegKeys.emplace_back(**vit); }
 
        // loop over segments and compare the current segment with the reference ones
        std::vector<std::pair<MuonSegmentKey, Trk::SegmentCollection::iterator> >::iterator skit = segKeys.begin();
        std::vector<std::pair<MuonSegmentKey, Trk::SegmentCollection::iterator> >::iterator skit_end = segKeys.end();
        for (; skit != skit_end; ++skit) {
            bool isDuplicate = false;
 
            std::vector<MuonSegmentKey>::iterator rskit = referenceSegKeys.begin();
            std::vector<MuonSegmentKey>::iterator rskit_end = referenceSegKeys.end();
 
            for (; rskit != rskit_end; ++rskit) {
                CompareMuonSegmentKeys::OverlapResult overlapResult = compareSegmentKeys(*rskit, skit->first);
                if (overlapResult == CompareMuonSegmentKeys::Identical) {
                    ATH_MSG_DEBUG(" discarding identical segment");
                    isDuplicate = true;
                    break;
                } else if (overlapResult == CompareMuonSegmentKeys::SuperSet) {
                    // reference segment superset of current: discard
                    ATH_MSG_DEBUG(" discarding (subset) ");
                    isDuplicate = true;
                    break;
                }
            }
            if (isDuplicate) segments->erase(skit->second);
        }
    }

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

splitTrack()

std::pair< std::unique_ptr< Trk::Track >, std::unique_ptr< Trk::Track > > Muon::MooTrackBuilder::splitTrack ( const EventContext & ctx, const Trk::Track & track ) const

private

split given track if it crosses the calorimeter volume, code assumes that the track was already extrapolated to the muon entry record using the MuonTrackExtrapolationTool.

It uses the double perigee to spot the tracks to be split.

Definition at line 897 of file MooTrackBuilder.cxx.

                                                                                                                                               {
        // use slFitter for straight line fit, or toroid off, otherwise use normal Fitter
 
        if (m_edmHelperSvc->isSLTrack(track)) return m_slFitter->splitTrack(ctx, track);
 
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
        const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
        if (!fieldCondObj) {
            ATH_MSG_ERROR("splitTrack: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return {};
        }
        fieldCondObj->getInitializedCache(fieldCache);
 
        if (!fieldCache.toroidOn()) return m_slFitter->splitTrack(ctx, track);
 
        return m_fitter->splitTrack(ctx, track);
    }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_candidateHandler

ToolHandle<MuPatCandidateTool> Muon::MooTrackBuilder::m_candidateHandler

private

Initial value:

{this, "CandidateTool",
                                                          "Muon::MuPatCandidateTool/MuPatCandidateTool"}

candidate handler

Definition at line 257 of file MooTrackBuilder.h.

                                                         {this, "CandidateTool",
                                                          "Muon::MuPatCandidateTool/MuPatCandidateTool"};  

m_candidateMatchingTool

ToolHandle<MooCandidateMatchingTool> Muon::MooTrackBuilder::m_candidateMatchingTool

private

Initial value:

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

Definition at line 259 of file MooTrackBuilder.h.

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

m_compRotCreator

ToolHandle<IMuonCompetingClustersOnTrackCreator> Muon::MooTrackBuilder::m_compRotCreator

private

Initial value:

{
            this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator"}

Definition at line 272 of file MooTrackBuilder.h.

                                                                         {
            this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator"};

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_doTimeOutChecks

Gaudi::Property<bool> Muon::MooTrackBuilder::m_doTimeOutChecks {this, "UseTimeOutGuard", true}

private

on/off time out check

Definition at line 290 of file MooTrackBuilder.h.

{this, "UseTimeOutGuard", true};  

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MooTrackBuilder::m_edmHelperSvc

private

Initial value:

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

Definition at line 263 of file MooTrackBuilder.h.

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

m_errorOptimisationTool

ToolHandle<IMuonErrorOptimisationTool> Muon::MooTrackBuilder::m_errorOptimisationTool {this, "ErrorOptimisationTool", ""}

private

Definition at line 283 of file MooTrackBuilder.h.

{this, "ErrorOptimisationTool", ""};

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_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Muon::MooTrackBuilder::m_fieldCacheCondObjInputKey

private

Initial value:

{this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"}

Definition at line 286 of file MooTrackBuilder.h.

                                                                               {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"};

m_fitter

ToolHandle<MooTrackFitter> Muon::MooTrackBuilder::m_fitter {this, "Fitter", "Muon::MooTrackFitter/MooTrackFitter", "Tool to fit segments to tracks"}

private

Definition at line 255 of file MooTrackBuilder.h.

{this, "Fitter", "Muon::MooTrackFitter/MooTrackFitter", "Tool to fit segments to tracks"};

m_idHelperSvc

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

private

Definition at line 267 of file MooTrackBuilder.h.

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

m_magFieldProperties

Trk::MagneticFieldProperties Muon::MooTrackBuilder::m_magFieldProperties {Trk::FullField}

private

magnetic field properties

Definition at line 288 of file MooTrackBuilder.h.

{Trk::FullField};  

m_mdtRotCreator

ToolHandle<IMdtDriftCircleOnTrackCreator> Muon::MooTrackBuilder::m_mdtRotCreator

private

Initial value:

{this, "MdtRotCreator",
                                                                  "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"}

Definition at line 270 of file MooTrackBuilder.h.

                                                                 {this, "MdtRotCreator",
                                                                  "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"};

m_muonChamberHoleRecoverTool

ToolHandle<IMuonHoleRecoveryTool> Muon::MooTrackBuilder::m_muonChamberHoleRecoverTool

private

Initial value:

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

Definition at line 277 of file MooTrackBuilder.h.

                                                                      {
            this, "ChamberHoleRecoveryTool",
            "Muon::MuonChamberHoleRecoveryTool/MuonChamberHoleRecoveryTool"};  //<! tool to add holes on track

m_ncalls

std::atomic_uint Muon::MooTrackBuilder::m_ncalls {0}

mutableprivate

Definition at line 296 of file MooTrackBuilder.h.

{0};

m_nTimedOut

std::atomic_uint Muon::MooTrackBuilder::m_nTimedOut {0}

mutableprivate

Definition at line 297 of file MooTrackBuilder.h.

{0};

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MooTrackBuilder::m_printer

private

Initial value:

{this, "Printer",
                                                 "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

tool to print out EDM objects;

Definition at line 265 of file MooTrackBuilder.h.

                                                      {this, "Printer",
                                                 "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};  

m_propagator

ToolHandle<Trk::IPropagator> Muon::MooTrackBuilder::m_propagator {this, "Propagator", "Trk::STEP_Propagator/MuonPropagator"}

private

Definition at line 274 of file MooTrackBuilder.h.

{this, "Propagator", "Trk::STEP_Propagator/MuonPropagator"};

m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> Muon::MooTrackBuilder::m_pullCalculator

private

Initial value:

{this, "PullCalculator",
                                                                  "Trk::ResidualPullCalculator/ResidualPullCalculator"}

Definition at line 275 of file MooTrackBuilder.h.

                                                               {this, "PullCalculator",
                                                                  "Trk::ResidualPullCalculator/ResidualPullCalculator"};

m_recalibrateMDTHits

Gaudi::Property<bool> Muon::MooTrackBuilder::m_recalibrateMDTHits {this, "RecalibrateMDTHitsOnTrack", true}

private

Definition at line 295 of file MooTrackBuilder.h.

{this, "RecalibrateMDTHitsOnTrack", true};

m_seededSegmentFinder

ToolHandle<IMuonSeededSegmentFinder> Muon::MooTrackBuilder::m_seededSegmentFinder

private

Initial value:

{this, "SeededSegmentFinder",
                                                                   "Muon::MuonSeededSegmentFinder/MuonSeededSegmentFinder"}

Definition at line 268 of file MooTrackBuilder.h.

                                                                  {this, "SeededSegmentFinder",
                                                                   "Muon::MuonSeededSegmentFinder/MuonSeededSegmentFinder"};

m_slFitter

ToolHandle<MooTrackFitter> Muon::MooTrackBuilder::m_slFitter {this, "SLFitter", "Muon::MooTrackFitter/MooSLTrackFitter", "Tool to fit segments to tracks"}

private

Definition at line 256 of file MooTrackBuilder.h.

{this, "SLFitter", "Muon::MooTrackFitter/MooSLTrackFitter", "Tool to fit segments to tracks"};

m_trackExtrapolationTool

ToolHandle<IMuonTrackExtrapolationTool> Muon::MooTrackBuilder::m_trackExtrapolationTool

private

Initial value:

{
            this, "Extrapolator", "Muon::MuonTrackExtrapolationTool/MuonTrackExtrapolationTool"}

Definition at line 280 of file MooTrackBuilder.h.

                                                                        {
            this, "Extrapolator", "Muon::MuonTrackExtrapolationTool/MuonTrackExtrapolationTool"};  //<! track extrapolation tool

m_trackSummaryTool

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

private

Definition at line 284 of file MooTrackBuilder.h.

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

m_trackToSegmentTool

ToolHandle<IMuonTrackToSegmentTool> Muon::MooTrackBuilder::m_trackToSegmentTool

private

Initial value:

{this, "TrackToSegmentTool",
                                                                 "Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool"}

Definition at line 261 of file MooTrackBuilder.h.

                                                                {this, "TrackToSegmentTool",
                                                                 "Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool"};

m_useExclusionList

Gaudi::Property<bool> Muon::MooTrackBuilder::m_useExclusionList

private

Initial value:

{this, "UseExclusionList",
                                                 true}

use exclusion list (bit faster at the price of missing chambers)

Definition at line 291 of file MooTrackBuilder.h.

                                              {this, "UseExclusionList",
                                                 true};  

m_useTrackingHistory

Gaudi::Property<bool> Muon::MooTrackBuilder::m_useTrackingHistory

private

Initial value:

{this, "UseTrackingHistory",
                                                   true}

use history of the track finding up to now to avoid creating duplicates

Definition at line 293 of file MooTrackBuilder.h.

                                                {this, "UseTrackingHistory",
                                                   true};  

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:

• MooTrackBuilder.h
• MooTrackBuilder.cxx