Muon::MooCandidateMatchingTool Class Reference

class to manipulate MuPatCandidateBase objects More...

#include <MooCandidateMatchingTool.h>

Inheritance diagram for Muon::MooCandidateMatchingTool:

Collaboration diagram for Muon::MooCandidateMatchingTool:

Classes
struct	MooTrackSegmentMatchResult
	Class with matching return information. More...

Public Member Functions
	MooCandidateMatchingTool (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor
virtual	~MooCandidateMatchingTool ()
	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
bool	match (const EventContext &ctx, const MuPatSegment &entry1, const MuPatSegment &entry2, bool useTightCuts) const
	match two segment entries
bool	match (const EventContext &ctx, const MuPatTrack &entry1, const MuPatSegment &entry2, bool useTightCuts) const
	match a segment entry with a track entry
bool	match (const EventContext &ctx, const MuPatCandidateBase &entry1, const MuPatSegment &entry2, bool useTightCuts) const
	match a segment entry with a base entry
virtual bool	match (const EventContext &ctx, const Trk::Track &track, const MuonSegment &segment, bool useTightCuts) const override
	match a track with a segment
void	calculateTrackSegmentMatchResult (const EventContext &ctx, const MuPatTrack &entry1, const MuPatSegment &entry2, MooTrackSegmentMatchResult &info) const
	calculate the info needed for the matching decision
TrackSegmentMatchCuts	getMatchingCuts (const MuPatTrack &entry1, const MuPatSegment &entry2, bool useTightCuts) const
bool	applyTrackSegmentCuts (const EventContext &ctx, MooTrackSegmentMatchResult &info, const TrackSegmentMatchCuts &cuts) const
bool	sameSide (const MuPatSegment &entry1, const MuPatSegment &entry2, bool requireSameSideOfPerigee) const
	check whether two segments are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.
bool	sameSide (const MuPatTrack &entry1, const MuPatSegment &entry2, bool requireSameSideOfPerigee) const
	Check whether the track and segment are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.
bool	sameSide (const MuPatTrack &entry1, const MuPatTrack &entry2, bool requireSameSideOfPerigee) const
	check whether the two tracks are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.
bool	sameSide (const Amg::Vector3D &dir, const Amg::Vector3D &pos1, const Amg::Vector3D &pos2, bool requireSameSideOfPerigee) const
	check whether two positions are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.
bool	checkSegmentDistance (const MuPatSegment &entry1, const MuPatSegment &entry2) const
	evaluate distance between two segments, if too large return false (cut at 3000.).
bool	areInNeighbouringChambers (const MuPatSegment &seg1, const MuPatSegment &seg2) const
	return whether the 2 segments are in neighbouring chambers
	DeclareInterfaceID (IMuonTrackSegmentMatchingTool, 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
static void	getIdentifierSet (const std::vector< const Trk::MeasurementBase * > &measurements, std::set< Identifier > &ids)
	extract Idenfitiers from a vector of measurements and copy them into a set
static bool	checkPhiHitConsistency (const MuPatCandidateBase &entry1, const MuPatCandidateBase &entry2)
	evaluate overlap between phi hits of two entries.

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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
double	m_minimumSideMatchRadius
double	m_matchAngXCut
double	m_matchAngYCut
double	m_matchAngXPullCut
double	m_matchAngYPullCut
double	m_matchPosXCut
double	m_matchPosYCut
double	m_matchPosPullCut
double	m_alignErrorPosX
double	m_alignErrorPosY
double	m_alignErrorAngleX
double	m_alignErrorAngleY
double	m_matchChiSquaredCut
double	m_matchChiSquaredCutTight
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
PublicToolHandle< MuonEDMPrinterTool >	m_printer
ToolHandle< Trk::IExtrapolator >	m_atlasExtrapolator
ToolHandle< IMuonSegmentMatchingTool >	m_segmentMatchingTool
ToolHandle< IMuonSegmentMatchingTool >	m_segmentMatchingToolTight
ToolHandle< MuPatCandidateTool >	m_candidateTool {this, "MuPatCandidateTool", "Muon::MuPatCandidateTool/MuPatCandidateTool"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
Gaudi::Property< int >	m_trackSegmentPreMatchingStrategy
Gaudi::Property< bool >	m_doTrackSegmentMatching {this, "DoTrackSegmentMatching", false, "Apply dedicated track-segment matching"}
std::atomic_ulong	m_goodSegmentMatches {0}
	matching counters
std::atomic_ulong	m_goodSegmentMatchesTight {0}
std::atomic_ulong	m_segmentMatches {0}
std::atomic_ulong	m_segmentMatchesTight {0}
std::atomic_ulong	m_goodSegmentTrackMatches {0}
std::atomic_ulong	m_goodSegmentTrackMatchesTight {0}
std::atomic_ulong	m_sameSideOfPerigee {0}
std::atomic_ulong	m_otherSideOfPerigee {0}
std::atomic_ulong	m_sameSideOfPerigeeTrk {0}
std::atomic_ulong	m_otherSideOfPerigeeTrk {0}
std::atomic_ulong	m_segmentTrackMatches {0}
std::atomic_ulong	m_segmentTrackMatchesTight {0}
std::atomic_ulong	m_reasonsForMatchOk [TrackSegmentMatchResult::NumberOfReasons] {0}
std::atomic_ulong	m_reasonsForMatchNotOk [TrackSegmentMatchResult::NumberOfReasons] {0}
double	m_caloMatchZ
	Z position of calo end-cap disks.
bool	m_requireSameSide
	require entries to be on the same side of the Perigee or Calorimeter
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

class to manipulate MuPatCandidateBase objects

Definition at line 48 of file MooCandidateMatchingTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MooCandidateMatchingTool()

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

default AlgTool constructor

Definition at line 61 of file MooCandidateMatchingTool.cxx.

                                                                                                                  :
        AthAlgTool(t, n, p) {
        declareInterface<MooCandidateMatchingTool>(this);
        declareInterface<IMuonTrackSegmentMatchingTool>(this);
 
        declareProperty("RequireSameSide", m_requireSameSide = false,
                        "require entries to be on the same side of the Perigee or Calorimeter");
        declareProperty("MinimumRadiusSideMatch", m_minimumSideMatchRadius = 4000., "All intersects outside the radius will be accepted");
        declareProperty("CaloMatchZ", m_caloMatchZ = 6500., "limit in Z to determine Calo crossing");
        declareProperty("MatchAngleXCut", m_matchAngXCut = 0.1,
                        "Local X (phi) angle difference cut for track-segment matching. Disabled if 0");
        declareProperty("MatchAngleYCut", m_matchAngYCut = 0.01,
                        "Local Y (theta) angle difference cut for track-segment matching. Disabled if 0");
        declareProperty("MatchAngleXPullCut", m_matchAngXPullCut = 10.0,
                        "Local X (phi) angle difference pull cut for track-segment matching. Disabled if 0");
        declareProperty("MatchAngleYPullCut", m_matchAngYPullCut = 25.0,
                        "Local Y (theta) angle difference pull cut for track-segment matching. Disabled if 0");
        declareProperty("MatchPosXCut", m_matchPosXCut = 100.0,
                        "Local X (2nd coord) position difference cut (mm) for track-segment matching. Disabled if 0");
        declareProperty("MatchPosYCut", m_matchPosYCut = 30.0,
                        "Local Y (precision) position difference cut (mm) for track-segment matching. Disabled if 0");
        declareProperty("MatchPosPullCut", m_matchPosPullCut = 10.0, "Local position pull cut for track-segment matching. Disabled if 0");
        declareProperty("MatchChiSquaredCut", m_matchChiSquaredCut = 100.0, "Cut on the track-segment matching chi-squared");
        declareProperty("MatchChiSquaredCutTight", m_matchChiSquaredCutTight = 25.0,
                        "Cut on the track-segment matching chi-squared in case a tight cut is requested");
        declareProperty("AlignmentErrorPosX", m_alignErrorPosX = 0.0, "Alignment precision in local X direction");
        declareProperty("AlignmentErrorPosY", m_alignErrorPosY = 0.0, "Alignment precision in local Y direction");
        declareProperty("AlignmentErrorAngleX", m_alignErrorAngleX = 0.0, "Alignment precision in local X angle");
        declareProperty("AlignmentErrorAngleY", m_alignErrorAngleY = 0.0, "Alignment precision in local Y angle");
 
        for (unsigned int i = 0; i < TrackSegmentMatchResult::NumberOfReasons; i++) {
            m_reasonsForMatchOk[i].store(0, std::memory_order_relaxed);
            m_reasonsForMatchNotOk[i].store(0, std::memory_order_relaxed);
        }
    }

~MooCandidateMatchingTool()

Muon::MooCandidateMatchingTool::~MooCandidateMatchingTool ( )

virtualdefault

destructor

Member Function Documentation

applyTrackSegmentCuts()

bool Muon::MooCandidateMatchingTool::applyTrackSegmentCuts	(	const EventContext &	ctx,
		MooTrackSegmentMatchResult &	info,
		const TrackSegmentMatchCuts &	cuts ) const

Definition at line 383 of file MooCandidateMatchingTool.cxx.

                                                                                                                                                           {
        if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << "track segment match:";
 
        if (info.reason == TrackSegmentMatchResult::NoMomentumWithMagField) {
            // for tracks that have no momentum, but need a curved match
            // fall-back to segment matching with the closest segment
            MuPatSegment* closestSegment = nullptr;
            double closestSegmentDist = 1E9;
            std::vector<MuPatSegment*>::const_iterator itS = info.MCTBTrack->segments().begin(), itS_end = info.MCTBTrack->segments().end();
            for (; itS != itS_end; ++itS) {
                // calculate distance along the direction of the segment on the track
                double dist =
                    (info.MCTBSegment->entryPars().position() - (*itS)->entryPars().position()).dot((*itS)->entryPars().momentum().unit());
                // store closest distance
                if (std::abs(dist) < std::abs(closestSegmentDist)) {
                    closestSegmentDist = dist;
                    closestSegment = *itS;
                }
            }
 
            if (!closestSegment) {
                info.reason = TrackSegmentMatchResult::NoClosestSegment;
                info.matchOK = true;
            } else {  // closestSegment
                // call segment matching tool
                if (cuts.useTightCuts) {
                    info.matchOK = m_segmentMatchingToolTight->match(ctx, *(closestSegment->segment), *(info.segment));
                } else {
                    info.matchOK = m_segmentMatchingTool->match(ctx, *(closestSegment->segment), *(info.segment));
                }
                if (msgLvl(MSG::DEBUG)) {
                    if (info.matchOK) {
                        msg(MSG::DEBUG) << MSG::DEBUG << " -> Passed";
                    } else {
                        msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed";
                    }
                    msg(MSG::DEBUG) << " segment match between segment-on-track "
                                    << MuonStationIndex::chName(m_idHelperSvc->chamberIndex(info.trackChamberId)) << " and segment "
                                    << MuonStationIndex::chName(m_idHelperSvc->chamberIndex(info.segmentChamberId)) << endmsg;
                }
                info.reason = TrackSegmentMatchResult::SegmentMatch;
                info.trackChamberId = closestSegment->chid;
            }  // else closestSegment
 
            return info.matchOK;
        }  // if ( info.reason == TrackSegmentMatchResult::NoMomentumWithMagField )
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::DEBUG) << MSG::VERBOSE << std::fixed;
            if (info.havePosXError) {
                double diff = info.localPosXDiff;
                double totErr = std::sqrt(info.posXTotalErr2);
                double pull = totErr != 0.0 ? diff / totErr : 0.0;
                msg(MSG::DEBUG) << std::endl
                                << std::setprecision(3) << "deltaPosX  =" << std::setw(8) << diff << " +- " << std::left << std::setw(8)
                                << totErr << std::right << std::setprecision(2) << " pull=" << std::setw(5) << pull << std::setprecision(3)
                                << " (align=" << m_alignErrorPosX << " meas=" << std::sqrt(info.posXMeasErr2)
                                << " pred=" << std::sqrt(info.posXPredErr2) << ")";
            }
            if (info.havePosYError) {
                double diff = info.localPosYDiff;
                double totErr = std::sqrt(info.posYTotalErr2);
                double pull = totErr != 0.0 ? diff / totErr : 0.0;
                msg(MSG::DEBUG) << std::endl
                                << std::setprecision(3) << "deltaPosY  =" << std::setw(8) << diff << " +- " << std::left << std::setw(8)
                                << totErr << std::right << std::setprecision(2) << " pull=" << std::setw(5) << pull
                                << " (align=" << m_alignErrorPosY << " meas=" << std::sqrt(info.posYMeasErr2)
                                << " pred=" << std::sqrt(info.posYPredErr2) << ")";
            }
            if (info.haveAngleXError) {
                double diff = info.localAngleXDiff;
                double totErr = std::sqrt(info.angleXTotalErr2);
                double pull = totErr != 0.0 ? diff / totErr : 0.0;
                msg(MSG::DEBUG) << std::endl
                                << std::setprecision(5) << "deltaAngleX=" << std::setw(8) << diff << " +- " << std::left << std::setw(8)
                                << totErr << std::right << std::setprecision(2) << " pull=" << std::setw(5) << pull << std::setprecision(5)
                                << " (align=" << m_alignErrorAngleX << " meas=" << std::sqrt(info.angleXMeasErr2)
                                << " pred=" << std::sqrt(info.angleXPredErr2) << ")";
            }
            if (info.haveAngleYError) {
                double diff = info.localAngleYDiff;
                double totErr = std::sqrt(info.angleYTotalErr2);
                double pull = totErr != 0.0 ? diff / totErr : 0.0;
                msg(MSG::DEBUG) << std::endl
                                << std::setprecision(5) << "deltaAngleY=" << std::setw(8) << diff << " +- " << std::left << std::setw(8)
                                << totErr << std::right << std::setprecision(2) << " pull=" << std::setw(5) << pull << std::setprecision(5)
                                << " (align=" << m_alignErrorAngleY << " meas=" << std::sqrt(info.angleYMeasErr2)
                                << " pred=" << std::sqrt(info.angleYPredErr2) << ")";
            }
 
            msg(MSG::DEBUG) << std::endl << std::setprecision(5) << "Difference vector:" << info.diffVector;
            msg(MSG::DEBUG) << printCovCorr(info.measuredCovariance, "Measured") << printCovCorr(info.predictionCovariance, "Predicted")
                            << printCovCorr(info.totalCovariance, "Total") << "Match chi-squared: " << info.matchChiSquared
                            << " sqrt=" << std::sqrt(info.matchChiSquared);
 
            // finish on new line
            if (info.havePosXError || info.havePosYError || info.haveAngleXError || info.haveAngleYError) { msg(MSG::DEBUG) << std::endl; }
        }
 
        //
        // Start checking all cuts
        //
        info.resetCuts();
        //
        // apply cut on positions
        //
        double scaledPosXErr2 = cuts.posXPullCut * cuts.posXPullCut * info.posXTotalErr2;
 
        // cut on absolute X position
        if (cuts.cutOnPosX && info.havePosX) {
            double posXCut2 = cuts.posXCut * cuts.posXCut + scaledPosXErr2;
            if (info.localPosXDiff * info.localPosXDiff > posXCut2) {
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName(m_idHelperSvc->chamberIndex(info.segmentChamberId))
                                    << " X position cut: " << info.localPosXDiff << " > " << std::sqrt(posXCut2) << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::PosXCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::PosXCut);
            }
        }
 
        double scaledPosYErr2 = cuts.posYPullCut * cuts.posYPullCut * info.posYTotalErr2;
 
        // cut on absolute Y position
        if (cuts.cutOnPosY && info.havePosY) {
            double posYCut2 = cuts.posYCut * cuts.posYCut + scaledPosYErr2;
            if (info.localPosYDiff * info.localPosYDiff > posYCut2) {
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " Y position cut: " << info.localPosYDiff << " > " << std::sqrt(posYCut2) << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::PosYCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::PosYCut);
            }
        }
 
        // cut on X position pull
        if (cuts.cutOnPosXPull && info.havePosX && info.posXTotalErr2 > 0.0) {
            if (info.localPosXDiff * info.localPosXDiff > scaledPosXErr2) {
                if (msgLvl(MSG::DEBUG)) {
                    double pull = info.localPosXDiff / std::sqrt(info.posXTotalErr2);
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " X position pull cut: |" << pull << "| > " << cuts.posXPullCut << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::PosXPullCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::PosXPullCut);
            }
        }
 
        // cut on Y position pull
        if (cuts.cutOnPosYPull && info.havePosY && info.posYTotalErr2 > 0.0) {
            if (info.localPosYDiff * info.localPosYDiff > scaledPosYErr2) {
                if (msgLvl(MSG::DEBUG)) {
                    double pull = info.localPosYDiff / std::sqrt(info.posYTotalErr2);
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " Y position pull cut: |" << pull << "| > " << cuts.posYPullCut << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::PosYPullCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::PosYPullCut);
            }
        }
 
        //
        // apply cut on angles
        //
        double scaledAngleXErr2 = cuts.angleXPullCut * cuts.angleXPullCut * info.angleXTotalErr2;
 
        // cut on absolute X angle
        if (cuts.cutOnAngleX && info.haveAngleX) {
            double angleXCut2 = cuts.angleXCut * cuts.angleXCut + scaledAngleXErr2;
            if (info.localAngleXDiff * info.localAngleXDiff > angleXCut2) {
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName(m_idHelperSvc->chamberIndex(info.segmentChamberId))
                                    << " X angle cut: " << info.localAngleXDiff << " > " << std::sqrt(angleXCut2) << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::AngXCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::AngXCut);
            }
        }
 
        double scaledAngleYErr2 = cuts.angleYPullCut * cuts.angleYPullCut * info.angleYTotalErr2;
 
        // cut on absolute Y angle
        if (cuts.cutOnAngleY && info.haveAngleY) {
            double angleYCut2 = cuts.angleYCut * cuts.angleYCut + scaledAngleYErr2;
            if (info.localAngleYDiff * info.localAngleYDiff > angleYCut2) {
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " Y angle cut: " << info.localAngleYDiff << " > " << std::sqrt(angleYCut2) << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::AngYCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::AngYCut);
            }
        }
 
        // cut on X angle pull
        if (cuts.cutOnAngleXPull && info.haveAngleX && info.angleXTotalErr2 > 0.0) {
            if (info.localAngleXDiff * info.localAngleXDiff > scaledAngleXErr2) {
                if (msgLvl(MSG::DEBUG)) {
                    double pull = info.localAngleXDiff / std::sqrt(info.angleXTotalErr2);
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " X angle pull cut: |" << pull << "| > " << cuts.angleXPullCut << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::AngXPullCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::AngXPullCut);
            }
        }
 
        if (cuts.cutOnAngleYPull && info.haveAngleY && info.angleYTotalErr2 > 0.0) {
            // cut on Y angle pull
            if (info.localAngleYDiff * info.localAngleYDiff > scaledAngleYErr2) {
                if (msgLvl(MSG::DEBUG)) {
                    double pull = info.localAngleYDiff / std::sqrt(info.angleYTotalErr2);
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " Y angle pull cut: |" << pull << "| > " << cuts.angleYPullCut << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::AngYPullCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::AngYPullCut);
            }
        }
 
        //
        // Cut on total chiSquared
        //
        if (cuts.cutOnMatchChiSquared && info.haveMatchChiSquared) {
            // cut on matching chi-squared
            if (info.matchChiSquared > cuts.matchChiSquaredCut) {
                if (msgLvl(MSG::DEBUG)) {
                    msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed "
                                    << MuonStationIndex::chName((m_idHelperSvc->chamberIndex(info.segmentChamberId)))
                                    << " match chi-squared cut: " << info.matchChiSquared << " > " << cuts.matchChiSquaredCut << endmsg;
                }
                info.setCutFailed(TrackSegmentMatchResult::MatchChiSquaredCut);
            } else {
                info.setCutPassed(TrackSegmentMatchResult::MatchChiSquaredCut);
            }
        }
 
        //
        // Based on all cuts, decide to accept or reject
        //
 
        // match is OR of several matches
        info.matchOK = false;
        // if any cut was applied
        if (info.appliedAnyCut()) {
            if (info.passedAllCuts()) {
                info.matchOK = true;
                info.reason = TrackSegmentMatchResult::PassedAllCuts;
                if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << " -> Passed all cuts";
            } else if (info.passedCut(TrackSegmentMatchResult::MatchChiSquaredCut)) {
                info.matchOK = true;
                info.reason = TrackSegmentMatchResult::PassedMatchChiSquaredCut;
                if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << " -> Passed match chi-quared cut";
            } else if ((info.passedCut(TrackSegmentMatchResult::PosXCut) || info.passedCut(TrackSegmentMatchResult::PosXPullCut)) &&
                       (info.passedCut(TrackSegmentMatchResult::PosYCut) || info.passedCut(TrackSegmentMatchResult::PosYPullCut)) &&
                       (info.passedCut(TrackSegmentMatchResult::AngXCut) || info.passedCut(TrackSegmentMatchResult::AngXPullCut)) &&
                       (info.passedCut(TrackSegmentMatchResult::AngYCut) || info.passedCut(TrackSegmentMatchResult::AngYPullCut))) {
                info.matchOK = true;
                info.reason = TrackSegmentMatchResult::PassedPosAngleCuts;
                if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << " -> Passed cuts " << info.passedCutsString();
                if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed cuts " << info.failedCutsString();
            } else {
                info.reason = TrackSegmentMatchResult::FailedCuts;
                if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << MSG::DEBUG << " -> Failed cuts " << info.failedCutsString();
            }
        } else {  // !info.appliedCuts
            if (info.reason == TrackSegmentMatchResult::Unknown) {
                info.reason = TrackSegmentMatchResult::NoCutsApplied;
                if (msgLvl(MSG::DEBUG)) { msg(MSG::DEBUG) << MSG::DEBUG << ". No cuts applied"; }  // if msgLvl(MSG::DEBUG)
            }                                                                                      // if reason == Unknown
        }                                                                                          // !appliedCuts
 
        if (msgLvl(MSG::DEBUG)) {
            if (info.matchOK) {
                msg(MSG::DEBUG) << MSG::DEBUG << " -> Accepted because " << info.reasonString() << endmsg;
            } else {
                msg(MSG::DEBUG) << MSG::DEBUG << " -> Rejected because " << info.reasonString() << endmsg;
            }
        }
 
        return info.matchOK;
    }  // applyTrackSegmentCuts()

areInNeighbouringChambers()

bool Muon::MooCandidateMatchingTool::areInNeighbouringChambers	(	const MuPatSegment &	seg1,
		const MuPatSegment &	seg2 ) const

return whether the 2 segments are in neighbouring chambers

Definition at line 1231 of file MooCandidateMatchingTool.cxx.

                                                                                                                     {
        Identifier chid1 = seg1.chid;
        Identifier chid2 = seg2.chid;
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "check if chambers are neighbours: " << m_idHelperSvc->toStringChamber(chid1) << " and "
                              << m_idHelperSvc->toStringChamber(chid2) << ": ";
        }
        // if in same chamber, then OK
        if (chid1 == chid2) {
            if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "in same chamber" << endmsg;
            return true;
        }
        // check in r
        if (seg1.stIndex != seg2.stIndex) {
            if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "not in same station" << endmsg;
            return false;
        }
 
        // check in phi
        int secDiff = std::abs(m_idHelperSvc->sector(chid1) - m_idHelperSvc->sector(chid2));
        if (secDiff > 1 && secDiff != 15) {
            if (msgLvl(MSG::VERBOSE))
                msg(MSG::VERBOSE) << "sec1=" << m_idHelperSvc->sector(chid1) << "sec2=" << m_idHelperSvc->sector(chid2)
                                  << " => not in neighbouring phi " << endmsg;
            return false;
        }
 
        // check in eta
        if (seg1.isEndcap && seg2.isEndcap) {
            // both in endcap
            // endcap: can compare eta indices
            if (std::abs(m_idHelperSvc->stationEta(chid1) - m_idHelperSvc->stationEta(chid2)) > 1) {
                if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "not in neighbouring eta" << endmsg;
                return false;
            }
        } else if (!seg1.isEndcap && !seg2.isEndcap) {
            // both in barrel
            const std::string& stationName1 =
                m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(chid1));
            const std::string& stationName2 =
                m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(chid2));
            std::string exceptions("MRFG");
            if (exceptions.find(stationName1[2]) == std::string::npos && exceptions.find(stationName2[2]) == std::string::npos) {
                // the normal case
                if (std::abs(m_idHelperSvc->stationEta(chid1) - m_idHelperSvc->stationEta(chid2)) > 1) {
                    if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "not in neighbouring eta " << endmsg;
                    return false;
                }
            } else {
                // the exceptions: use geometrical information
                const std::set<const MuonGM::MuonReadoutElement*> roEls1 = m_candidateTool->readoutElements(seg1);
                const std::set<const MuonGM::MuonReadoutElement*> roEls2 = m_candidateTool->readoutElements(seg2);
                for (const MuonGM::MuonReadoutElement* read_ele1 : roEls1) {
                    for (const MuonGM::MuonReadoutElement* read_ele2 : roEls2) {
                        double distZ = std::abs(read_ele1->center().z() - read_ele2->center().z());
                        // subtract sizes
                        distZ -= 0.5 * (read_ele1->getZsize() + read_ele2->getZsize());
                        if (msgLvl(MSG::VERBOSE)) {
                            msg(MSG::VERBOSE) << std::endl
                                              << read_ele1->getStationType() << ": z=" << read_ele1->center().z() << "+-"
                                              << 0.5 * read_ele1->getZsize() << "  " << read_ele2->getStationType()
                                              << ": z=" << read_ele2->center().z() << "+-" << 0.5 * read_ele2->getZsize() << "  "
                                              << "distZ=" << distZ;
                        }
                        // allow some distance
                        if (distZ > 100.0) {
                            if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << " z-position too far apart" << endmsg;
                            return false;
                        }
                    }
                }
            }
        } else {
            // don't mix barrel/endcap
            ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<< "endcap/barrel mix");
            return false;
        }
 
        ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<< " Yes!");
        return true;
    }

calculateTrackSegmentMatchResult()

void Muon::MooCandidateMatchingTool::calculateTrackSegmentMatchResult	(	const EventContext &	ctx,
		const MuPatTrack &	entry1,
		const MuPatSegment &	entry2,
		MooTrackSegmentMatchResult &	info ) const

calculate the info needed for the matching decision

closestMeasPars

straighLineMatch && !entry1.hasMomemtum()

Definition at line 683 of file MooCandidateMatchingTool.cxx.

                                                                                                            {
        info.clear();
        info.MCTBTrack = &entry1;
        info.MCTBSegment = &entry2;
        info.track = &entry1.track();
        info.segment = entry2.segment;
        info.segmentChamberId = entry2.chid;
        if (!entry2.segment) {
            ATH_MSG_WARNING(__FUNCTION__ << " entry2 does not have segment pointer.");
            info.reason = TrackSegmentMatchResult::NoSegmentPointer;
            return;
        }
        int sector2 = m_idHelperSvc->sector(info.segmentChamberId);
        bool hasStereoAngle = false;
 
        // find closest track parameters
        const Trk::TrackParameters* closestPars = nullptr;
        double closestParsDist = 1E9;
        const Trk::TrackParameters* closestMeasPars = nullptr;
        double closestMeasParsDist = 1E9;
        // const Trk::TrackStateOnSurface* closestTSOS = 0;
        Identifier closestId;
        double closestIdDist = 1E9;
        bool trackHasPhi = true;
 
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
        const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
        if (fieldCondObj == nullptr) {
            ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return;
        }
        fieldCondObj->getInitializedCache(fieldCache);
 
        // loop over TSOS
        const Trk::TrackStates* tsoses = entry1.track().trackStateOnSurfaces();
        Trk::TrackStates::const_iterator tit = tsoses->begin();
        Trk::TrackStates::const_iterator tit_end = tsoses->end();
        for (; tit != tit_end; ++tit) {
            const Trk::MeasurementBase* meas = (*tit)->measurementOnTrack();
 
            // do not want to start from a pseudo-measurement
            const Trk::PseudoMeasurementOnTrack* pseudo = dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(meas);
            if (pseudo) {
                trackHasPhi = false;
                continue;
            }
 
            // do not want to start from non-MS measurements
            Identifier id;
            if (meas) {
                id = m_edmHelperSvc->getIdentifier(*meas);
                if (id.is_valid()) {
                    if (!m_idHelperSvc->isMuon(id)) continue;
                    if (m_idHelperSvc->isMdt(id) && m_idHelperSvc->sector(id) != sector2) hasStereoAngle = true;
                }
            }
 
            const Trk::TrackParameters* pars = (*tit)->trackParameters();
            if (!pars) { continue; }
 
            // calculate distance along the direction of the track
            double dist = (entry2.entryPars().position() - pars->position()).dot(entry1.entryPars().momentum().unit());
            // store closest distance
            if (std::abs(dist) < std::abs(closestParsDist)) {
                // closestTSOS = *tit;
                closestParsDist = dist;
                closestPars = pars;
                if (pars->covariance()) {
                    closestMeasParsDist = dist;
                    closestMeasPars = pars;
                }
            }
            // store closest MDT or CSC ID (for printout and performance analysis)
            if (std::abs(dist) < std::abs(closestIdDist)) {
                if (meas && id.is_valid() && m_idHelperSvc->isMuon(id) && (m_idHelperSvc->isMdt(id) || m_idHelperSvc->isCsc(id))) {
                    closestId = id;
                    closestIdDist = dist;
                }
            }
        }
 
        // update trackHasPhi in the cases where we do have enough phi constraints
        if (entry1.phiHits().size() > 1) {
            // calculate difference between hits
            const Amg::Vector3D& gposFirstPhi = entry1.phiHits().front()->globalPosition();
            const Amg::Vector3D& gposLastPhi = entry1.phiHits().back()->globalPosition();
            Amg::Vector3D globalDistance = gposLastPhi - gposFirstPhi;
 
            // calculate 'projective' distance
            double distance = entry1.hasEndcap() ? fabs(globalDistance.z()) : globalDistance.perp();
 
            if (distance > 500) trackHasPhi = true;
        }
 
        if (!closestPars) {
            ATH_MSG_DEBUG("track-segment match: No closest track parameters found.");
            info.reason = TrackSegmentMatchResult::NoClosestPars;
            return;
        }
 
        // set the identification of the first entry (the track - taking the closest point)
        if (closestPars && closestId.is_valid()) { info.trackChamberId = m_idHelperSvc->chamberId(closestId); }
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::DEBUG) << MSG::VERBOSE << "match Closest chamber: " << m_idHelperSvc->toStringChamber(info.trackChamberId)
                            << " Segment: " << m_idHelperSvc->toStringChamber(info.segmentChamberId);
            const Trk::TrackParameters* tmpPars = nullptr;
            if (closestMeasPars) tmpPars = closestMeasPars->covariance() ? closestMeasPars : nullptr;
            if (tmpPars) {
                msg(MSG::DEBUG) << std::endl
                                << "Closest measured track parameters: " << m_printer->print(*tmpPars) << std::endl
                                << Amg::toString(*tmpPars->covariance(), 10) << "  distance=" << closestMeasParsDist;
            }
            if (!tmpPars || tmpPars != closestPars) {
                msg(MSG::DEBUG) << std::endl
                                << "Closest track parameters         : " << m_printer->print(*closestPars)
                                << "  distance=" << closestParsDist;
            }
            msg(MSG::DEBUG) << endmsg;
        }
 
        bool straightLineMatch = !fieldCache.toroidOn();
        if (hasStereoAngle && !trackHasPhi && (straightLineMatch || entry1.hasMomentum())) {
            // can not do any extrapolation (not reliable)
            info.reason = TrackSegmentMatchResult::StereoAngleWithoutPhi;
            return;
        }
 
        // if extrapolating within EM-EO, can use straight-line extrapolator even without momentum
        if (!straightLineMatch && !entry1.hasMomentum() && info.trackChamberId.is_valid()) {
            MuonStationIndex::StIndex trackStationIndex = m_idHelperSvc->stationIndex(info.trackChamberId);
            MuonStationIndex::StIndex segmentStationIndex = entry2.stIndex;
            if (((trackStationIndex == MuonStationIndex::StIndex::EM && segmentStationIndex == MuonStationIndex::StIndex::EO) ||
                 (trackStationIndex == MuonStationIndex::StIndex::EO && segmentStationIndex == MuonStationIndex::StIndex::EM)) &&
                closestPars->position().z() * entry2.entryPars().position().z() > 0.0) {
                straightLineMatch = true;
                ATH_MSG_DEBUG("track in " << m_idHelperSvc->toStringStation(info.trackChamberId) << " and segment in "
                                          << m_idHelperSvc->toStringStation(info.segmentChamberId)
                                          << " => doing straight line extrapolation match");
            }
        }
 
        //
        // for tracks that have a momentum or have straight line match
        //
        if (straightLineMatch || entry1.hasMomentum()) {
            // extrapolate to segment surface
            std::unique_ptr<const Trk::TrackParameters> exPars;
            const Trk::TrackParameters* exMeasPars = nullptr;
            if (closestMeasPars) {
                const Trk::TrackParameters* tmpPars = closestMeasPars->covariance() ? closestMeasPars : nullptr;
 
                if (tmpPars) {
                    // Check sector+
                    if (!m_idHelperSvc->isMuon(info.trackChamberId)) {
                        info.reason = TrackSegmentMatchResult::SegmentMatching;
                        return;
                    }
                    int trackSector = m_idHelperSvc->sector(info.trackChamberId);
                    int segmentSector = m_idHelperSvc->sector(info.segmentChamberId);
                    int sectorDiff = std::abs(trackSector - segmentSector);
                    if (sectorDiff > 1 && sectorDiff != 15) {
                        ATH_MSG_VERBOSE("track sector   =" << trackSector << " segment sector =" << segmentSector
                                                           << " => not in neighbouring sectors ");
 
                        info.reason = TrackSegmentMatchResult::SegmentMatching;
                        return;
                    }
                    // Check sector-
 
                    if (straightLineMatch && !entry1.hasMomentum()) {
                        exPars = m_atlasExtrapolator->extrapolateDirectly(ctx, *tmpPars, entry2.segment->associatedSurface(),
                                                                          Trk::anyDirection, false, Trk::muon);
                    } else {
                        ATH_MSG_VERBOSE(" Extrapolating to other segment " << m_printer->print(*tmpPars) << std::endl
                                                                           << Amg::toString(*tmpPars->covariance(), 10));
                        exPars = m_atlasExtrapolator->extrapolate(ctx, *tmpPars, entry2.segment->associatedSurface(), Trk::anyDirection,
                                                                  false, Trk::muon);
                    }
                }
                if (!exPars) {
                    ATH_MSG_DEBUG("track-segment match: Failed to extrapolate measured track parameters\n"
                                  << m_printer->print(*closestPars) << "\nfrom " << m_idHelperSvc->toStringChamber(info.trackChamberId)
                                  << " to segment surface " << m_idHelperSvc->toStringChamber(info.segmentChamberId));
                    info.matchOK = false;
                    info.reason = TrackSegmentMatchResult::ExtrapolFailed;
                    return;
                }
 
                exMeasPars = exPars->covariance() ? exPars.get() : nullptr;
                if (!exMeasPars) {
                    ATH_MSG_DEBUG("track-segment match: Did not get measured track parameters from extrapolation\n"
                                  << "\nfrom " << m_idHelperSvc->toStringChamber(info.trackChamberId) << " to segment surface "
                                  << m_idHelperSvc->toStringChamber(info.segmentChamberId));
                    info.reason = TrackSegmentMatchResult::ExtrapolNoErrors;
                    return;
                }
                ATH_MSG_VERBOSE(" ExMeasParameters " << exMeasPars << " " << m_printer->print(*exMeasPars) << std::endl
                                                     << Amg::toString(*exMeasPars->covariance(), 10));
 
            } else {  
                // no closest measured parameters, take closest parameters
 
                if (straightLineMatch && !entry1.hasMomentum()) {
                    exPars = m_atlasExtrapolator->extrapolateDirectly(ctx, *closestPars, entry2.segment->associatedSurface(),
                                                                      Trk::anyDirection, false, Trk::muon);
                } else {
                    exPars = m_atlasExtrapolator->extrapolate(ctx, *closestPars, entry2.segment->associatedSurface(), Trk::anyDirection,
                                                              false, Trk::muon);
                }
                if (!exPars) {
                    ATH_MSG_DEBUG("track-segment match: Failed to extrapolate track parameters without errors\n"
                                  << m_printer->print(*closestPars) << "\nfrom " << m_idHelperSvc->toStringChamber(info.trackChamberId)
                                  << " to segment surface " << m_idHelperSvc->toStringChamber(info.segmentChamberId));
                    info.matchOK = false;
                    info.reason = TrackSegmentMatchResult::ExtrapolFailed;
                    return;
                }
            }
 
            // get the available measured information by looking at the errors
            // check measurement errors
            const Amg::MatrixX& measErrors = entry2.segment->localCovariance();
 
            double posXMeasErr2 = measErrors(Trk::locX, Trk::locX);
            if (posXMeasErr2 <= 999.0) {
                info.havePosX = true;
                info.havePosXError = true;
                info.posXMeasErr2 = posXMeasErr2;
                info.posXTotalErr2 += posXMeasErr2;
            }
 
            double posYMeasErr2 = measErrors(Trk::locY, Trk::locY);
            if (info.posYMeasErr2 <= 999.0) {
                info.havePosY = true;
                info.havePosYError = true;
                info.posYMeasErr2 = posYMeasErr2;
                info.posYTotalErr2 += posYMeasErr2;
            }
            double phiMeasErr2 = measErrors(Trk::phi, Trk::phi);
            double thetaMeasErr2 = measErrors(Trk::theta, Trk::theta);
            if (phiMeasErr2 <= 999.0) {
                info.haveAngleX = true;
                info.haveAngleXError = true;
                info.angleXMeasErr2 = phiMeasErr2;
                info.angleXTotalErr2 += phiMeasErr2;
            }
            if (thetaMeasErr2 <= 999.0) {
                info.haveAngleY = true;
                info.haveAngleYError = true;
                info.angleYMeasErr2 = thetaMeasErr2;
                info.angleYTotalErr2 += thetaMeasErr2;
            }
 
            // require extrapolation errors to enable use of errors
            if (!exMeasPars) {
                info.haveAngleXError = false;
                info.haveAngleYError = false;
                info.havePosXError = false;
                info.havePosYError = false;
            }
 
            // calculate position difference
            info.localPosXDiff = exPars->parameters()[Trk::locX] - entry2.segment->localParameters()[Trk::locX];
            info.localPosYDiff = exPars->parameters()[Trk::locY] - entry2.segment->localParameters()[Trk::locY];
 
            // calculate angle difference
            Trk::LocalDirection locDirEx;
            entry2.segment->associatedSurface().globalToLocalDirection(exPars->momentum(), locDirEx);
 
            const Trk::LocalDirection& locDirSeg = entry2.segment->localDirection();
 
            // angular residuals
            info.localAngleXDiff = phi_diff(locDirEx.angleXZ() - locDirSeg.angleXZ());
            info.localAngleYDiff = theta_diff(locDirEx.angleYZ() - locDirSeg.angleYZ());
 
            AmgSymMatrix(5) localPredCovar;
            localPredCovar.setIdentity();
            // only calculate if needed
            if (info.haveAngleXError || info.haveAngleYError || info.havePosXError || info.havePosYError) {
                // Predicted angle errors are on global phi and theta. Need to convert to errors on local angles
                Trk::JacobianPhiThetaLocalAngles globalToLocalPredAnglesJacobian(
                    exMeasPars->parameters()[Trk::phi], exMeasPars->parameters()[Trk::theta],
                    exMeasPars->associatedSurface().transform().rotation().inverse());
 
                // make the Jacobian to convert all in one go from global to local
                // so that the correlations are calculated correctly
                AmgSymMatrix(5) globalToLocalPredJacobian;
                globalToLocalPredJacobian.setIdentity();
                globalToLocalPredJacobian(Trk::locX, Trk::locX) = 1.0;
                globalToLocalPredJacobian(Trk::locY, Trk::locY) = 1.0;
                globalToLocalPredJacobian(Trk::phi, Trk::phi) = globalToLocalPredAnglesJacobian(0, 0);
                globalToLocalPredJacobian(Trk::theta, Trk::theta) = globalToLocalPredAnglesJacobian(1, 1);
                globalToLocalPredJacobian(Trk::theta, Trk::phi) =
                    globalToLocalPredAnglesJacobian(0, 1);  // also fills (Trk::phi,Trk::theta)
                globalToLocalPredJacobian(Trk::phi, Trk::theta) = globalToLocalPredJacobian(Trk::theta, Trk::phi);
                globalToLocalPredJacobian(Trk::qOverP, Trk::qOverP) = 1.0;
                const AmgSymMatrix(5)& globalPredCovar = *exMeasPars->covariance();
                localPredCovar = globalPredCovar.similarity(globalToLocalPredJacobian);
            }
 
            if (info.haveAngleXError && info.haveAngleYError && info.havePosXError && info.havePosYError) {
                // Full 4D info available: CSC segments and MDT small-large overlap
                info.measuredCovariance = measErrors.block<4, 4>(0, 0);        // sub(1,4); hope this is ok ....
                info.predictionCovariance = localPredCovar.block<4, 4>(0, 0);  // sub(1,4); hope this is ok ....
                info.totalCovariance = info.measuredCovariance + info.predictionCovariance;
 
                // add alignment errors
                info.totalCovariance(Trk::locX, Trk::locX) += m_alignErrorPosX * m_alignErrorPosX;
                info.totalCovariance(Trk::locY, Trk::locY) += m_alignErrorPosY * m_alignErrorPosY;
                info.totalCovariance(Trk::phi, Trk::phi) += m_alignErrorAngleX * m_alignErrorAngleX;
                info.totalCovariance(Trk::theta, Trk::theta) += m_alignErrorAngleY * m_alignErrorAngleY;
 
                // fill difference vector
                Amg::VectorX diffVec(4);
                diffVec[Trk::locX] = exPars->parameters()[Trk::locX] - entry2.segment->localParameters()[Trk::locX];
                diffVec[Trk::locY] = exPars->parameters()[Trk::locY] - entry2.segment->localParameters()[Trk::locY];
                diffVec[Trk::phi] = exPars->parameters()[Trk::phi] - entry2.segment->localParameters()[Trk::phi];
                diffVec[Trk::theta] = exPars->parameters()[Trk::theta] - entry2.segment->localParameters()[Trk::theta];
                info.diffVector = diffVec;
 
                // finally calculate the match chi-squared
                Amg::MatrixX weightMatrix = info.totalCovariance.inverse();
                info.matchChiSquared = info.diffVector.transpose() * weightMatrix * info.diffVector;
                info.haveMatchChiSquared = true;
 
                // update separate angles (redunant with covar)
                info.posXPredErr2 = localPredCovar(Trk::locX, Trk::locX);
                info.posYPredErr2 = localPredCovar(Trk::locY, Trk::locY);
                info.angleXPredErr2 = localPredCovar(Trk::phi, Trk::phi);
                info.angleYPredErr2 = localPredCovar(Trk::theta, Trk::theta);
                // update total errors
                info.posXTotalErr2 += info.posXPredErr2;
                info.posYTotalErr2 += info.posYPredErr2;
                info.angleXTotalErr2 += info.angleXPredErr2;
                info.angleYTotalErr2 += info.angleYPredErr2;
                info.posXTotalErr2 += m_alignErrorPosX * m_alignErrorPosX;
                info.posYTotalErr2 += m_alignErrorPosY * m_alignErrorPosY;
                info.angleXTotalErr2 += m_alignErrorAngleX * m_alignErrorAngleX;
                info.angleYTotalErr2 += m_alignErrorAngleY * m_alignErrorAngleY;
 
            } else if (info.haveAngleYError && info.havePosYError) {
                // 2D Y info available:
                // normal (non-overlap) MDT segments have no X nor phi(angleXZ) measurement, and give error on local angleYZ
 
                // Y,angleYZ 2x2 sub-set of predicted covariance
                AmgSymMatrix(2) predCovar{AmgSymMatrix(2)::Zero()};
                predCovar(0, 0) = localPredCovar(Trk::locY, Trk::locY);    // Y
                predCovar(1, 1) = localPredCovar(Trk::theta, Trk::theta);  // angleYZ
                predCovar(1, 0) = localPredCovar(Trk::theta, Trk::locY);   // also sets (0,1)
                predCovar(0, 1) = predCovar(1, 0);
                info.predictionCovariance = predCovar;
 
                // Y,angleYZ 2x2 sub-set of measured covariance
                AmgSymMatrix(2) measCovar{AmgSymMatrix(2)::Zero()};
                measCovar.setIdentity();
                measCovar(0, 0) = measErrors(Trk::locY, Trk::locY);
                measCovar(1, 1) = measErrors(Trk::theta, Trk::theta);
                measCovar(1, 0) = measErrors(Trk::theta, Trk::locY);
                measCovar(0, 1) = measCovar(1, 0);
 
                info.measuredCovariance = measCovar;
                info.totalCovariance = info.predictionCovariance + info.measuredCovariance;
                // add alignment errors
                info.totalCovariance(0, 0) += m_alignErrorPosY * m_alignErrorPosY;
                info.totalCovariance(1, 1) += m_alignErrorAngleY * m_alignErrorAngleY;
                if (std::abs(info.totalCovariance.determinant()) < 
                        std::numeric_limits<float>::epsilon()){
                    info.reason = TrackSegmentMatchResult::NoMeasErrors;
                    return;
                }
                // now fill the difference vector
                Amg::VectorX diffVec(2);
                diffVec[0] = info.localPosYDiff;
                diffVec[1] = info.localAngleYDiff;
                info.diffVector = diffVec;
 
                // finally calculate the match chi-squared
                Amg::MatrixX weightMatrix = info.totalCovariance.inverse();
                info.matchChiSquared = info.diffVector.transpose() * weightMatrix * info.diffVector;
                info.haveMatchChiSquared = true;
 
                // fill all available information (redundant with covar)
                info.posXPredErr2 = localPredCovar(Trk::locX, Trk::locX);
                info.posYPredErr2 = localPredCovar(Trk::locY, Trk::locY);
                info.angleXPredErr2 = localPredCovar(Trk::phi, Trk::phi);
                info.angleYPredErr2 = localPredCovar(Trk::theta, Trk::theta);
                // only use Y/angleY
                info.posYTotalErr2 += info.posYPredErr2;
                info.angleYTotalErr2 += info.angleYPredErr2;
                info.posYTotalErr2 += m_alignErrorPosY * m_alignErrorPosY;
                info.angleYTotalErr2 += m_alignErrorAngleY * m_alignErrorAngleY;
 
            } else {
                info.reason = TrackSegmentMatchResult::NoMeasErrors;
            }
 
        } else {  
            info.reason = TrackSegmentMatchResult::NoMomentumWithMagField;
            //
            // Alternative method:
            // EM/EO -> EI
            // extrapolate (straight line) from EM/EO track and line to IP -> matching region
 
        }  // else !straighLineMatch && !entry1.hasMomemtum()
 
    }

checkPhiHitConsistency()

bool Muon::MooCandidateMatchingTool::checkPhiHitConsistency ( const MuPatCandidateBase & entry1, const MuPatCandidateBase & entry2 )

static

evaluate overlap between phi hits of two entries.

returns true if the entries share all phi hits or the phi hits of one of the entries are subset of the other

Definition at line 1198 of file MooCandidateMatchingTool.cxx.

                                                                                                                            {
        // check whether one of the two entries has no phi hits in which case return true
        if (entry1.phiHits().empty() || entry2.phiHits().empty()) return true;
 
        std::set<Identifier> ids1;
        getIdentifierSet(entry1.phiHits(), ids1);
 
        std::set<Identifier> ids2;
        getIdentifierSet(entry2.phiHits(), ids2);
 
        std::vector<Identifier> intersection;
        std::set_intersection(ids1.begin(), ids1.end(), ids2.begin(), ids2.end(), std::back_inserter(intersection));
 
        unsigned int intersectionSize = intersection.size();
        // require a full overlap between the two entries or that one of the two is a subset of the other
        if (intersectionSize == ids1.size() || intersectionSize == ids2.size()) return true;
 
        // also accept if there is no overlap
        if (intersectionSize == 0) return true;
 
        return false;
    }

checkSegmentDistance()

bool Muon::MooCandidateMatchingTool::checkSegmentDistance	(	const MuPatSegment &	entry1,
		const MuPatSegment &	entry2 ) const

evaluate distance between two segments, if too large return false (cut at 3000.).

Definition at line 1221 of file MooCandidateMatchingTool.cxx.

                                                                                                                    {
        DistanceToPars distToPars(&entry1.entryPars());
        double distance = distToPars(entry2.entryPars().position());
        if (std::abs(distance) > 5000.) {
            ATH_MSG_VERBOSE("  large distance between segments, not using segment " << distance);
            return false;
        }
        return true;
    }

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::IMuonTrackSegmentMatchingTool::DeclareInterfaceID ( IMuonTrackSegmentMatchingTool , 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::MooCandidateMatchingTool::finalize ( )

overridevirtual

finialize method, method taken from bass-class AlgTool

Definition at line 112 of file MooCandidateMatchingTool.cxx.

                                                  {
        int segmentMatchesLoose = m_segmentMatches - m_segmentMatchesTight;
        int goodSegmentMatchesLoose = m_goodSegmentMatches - m_goodSegmentMatchesTight;
        double sameScale = m_sameSideOfPerigee != 0 ? m_segmentMatches / m_sameSideOfPerigee : 1.;
        double scale = m_segmentMatches != 0 ? 1. / ((double)m_segmentMatches) : 1.;
        double scaleTight = m_segmentMatchesTight != 0 ? 1. / ((double)m_segmentMatchesTight) : 1.;
        double scaleLoose = segmentMatchesLoose != 0.0 ? 1. / ((double)segmentMatchesLoose) : 1.;
        msg(MSG::INFO) << std::fixed << std::setprecision(3);
        msg(MSG::INFO) << "Segment/segment matches: total " << std::setw(7) << m_segmentMatches << "  tight " << std::setw(7)
                       << m_segmentMatchesTight << endmsg << " same side  " << std::setw(7) << m_sameSideOfPerigee << " fraction "
                       << m_sameSideOfPerigee * scale << endmsg << " other side " << std::setw(7) << m_otherSideOfPerigee << " fraction "
                       << m_otherSideOfPerigee * scale << endmsg << " good total " << std::setw(7) << m_goodSegmentMatches << " fraction "
                       << m_goodSegmentMatches * scale * sameScale << endmsg << " good loose " << std::setw(7) << goodSegmentMatchesLoose
                       << " fraction " << goodSegmentMatchesLoose * scaleLoose * sameScale << endmsg << " good tight " << std::setw(7)
                       << m_goodSegmentMatchesTight << " fraction " << m_goodSegmentMatchesTight * scaleTight * sameScale << endmsg;
 
        int segmentTrackMatchesLoose = m_segmentTrackMatches - m_segmentTrackMatchesTight;
        int goodSegmentTrackMatchesLoose = m_goodSegmentTrackMatches - m_goodSegmentTrackMatchesTight;
        double sameScaleTrack = m_sameSideOfPerigeeTrk != 0 ? m_segmentTrackMatches / m_sameSideOfPerigeeTrk : 1.;
        double scaleTrack = m_segmentTrackMatches != 0 ? 1. / ((double)m_segmentTrackMatches) : 1.;
        double scaleTrackTight = m_segmentTrackMatchesTight != 0 ? 1. / ((double)m_segmentTrackMatchesTight) : 1.;
        double scaleTrackLoose = segmentTrackMatchesLoose != 0.0 ? 1. / ((double)segmentTrackMatchesLoose) : 1.;
        msg(MSG::INFO) << "Track/segment matches:   total " << std::setw(7) << m_segmentTrackMatches << "  tight " << std::setw(7)
                       << m_segmentTrackMatchesTight << endmsg << " same side  " << std::setw(7) << m_sameSideOfPerigeeTrk << " fraction "
                       << m_sameSideOfPerigeeTrk * scaleTrack << endmsg << " other side " << std::setw(7) << m_otherSideOfPerigeeTrk
                       << " fraction " << m_otherSideOfPerigeeTrk * scaleTrack << endmsg << " good total " << std::setw(7)
                       << m_goodSegmentTrackMatches << " fraction " << m_goodSegmentTrackMatches * scaleTrack * sameScaleTrack << endmsg
                       << " good loose " << std::setw(7) << goodSegmentTrackMatchesLoose << " fraction "
                       << goodSegmentTrackMatchesLoose * scaleTrackLoose * sameScaleTrack << endmsg << " good tight " << std::setw(7)
                       << m_goodSegmentTrackMatchesTight << " fraction "
                       << m_goodSegmentTrackMatchesTight * scaleTrackTight * sameScaleTrack << endmsg;
        // get printing width
        unsigned int nReasons = (int)TrackSegmentMatchResult::NumberOfReasons;
        unsigned int width = 0;
        for (unsigned int i = 0; i < nReasons; ++i) {
            unsigned int w = TrackSegmentMatchResult::reasonString(TrackSegmentMatchResult::Reason(i)).length();
            if (w > width) width = w;
        }
        // print it
        msg(MSG::INFO) << " Reasons for match failures:" << endmsg;
        for (unsigned int i = 0; i < nReasons; ++i) {
            int cnt = m_reasonsForMatchNotOk[i];
            TrackSegmentMatchResult::Reason reason = TrackSegmentMatchResult::Reason(i);
            if (cnt > 0)
                msg(MSG::INFO) << "  " << std::left << std::setw(width) << TrackSegmentMatchResult::reasonString(reason) << std::right
                               << ": " << cnt << endmsg;
        }
        msg(MSG::INFO) << " Reasons for match successes:" << endmsg;
        for (unsigned int i = 0; i < nReasons; ++i) {
            int cnt = m_reasonsForMatchOk[i];
            TrackSegmentMatchResult::Reason reason = TrackSegmentMatchResult::Reason(i);
            if (cnt > 0)
                msg(MSG::INFO) << "  " << std::left << std::setw(width) << TrackSegmentMatchResult::reasonString(reason) << std::right
                               << ": " << cnt << endmsg;
        }
 
        return StatusCode::SUCCESS;
    }

getIdentifierSet()

void Muon::MooCandidateMatchingTool::getIdentifierSet ( const std::vector< const Trk::MeasurementBase * > & measurements, std::set< Identifier > & ids )

static

extract Idenfitiers from a vector of measurements and copy them into a set

Definition at line 1177 of file MooCandidateMatchingTool.cxx.

                                                                             {
        // loop over measurements and extract all identifiers
        std::vector<const Trk::MeasurementBase*>::const_iterator it = measurements.begin();
        std::vector<const Trk::MeasurementBase*>::const_iterator it_end = measurements.end();
        for (; it != it_end; ++it) {
            const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(*it);
            if (rot) {
                ids.insert(rot->identify());
            } else {
                const CompetingMuonClustersOnTrack* crot = dynamic_cast<const CompetingMuonClustersOnTrack*>(*it);
                if (crot) {
                    const std::vector<const MuonClusterOnTrack*>& rots = crot->containedROTs();
                    std::vector<const MuonClusterOnTrack*>::const_iterator rit = rots.begin();
                    std::vector<const MuonClusterOnTrack*>::const_iterator rit_end = rots.end();
                    for (; rit != rit_end; ++rit) ids.insert((*rit)->identify());
                }
            }
        }
    }

getMatchingCuts()

TrackSegmentMatchCuts Muon::MooCandidateMatchingTool::getMatchingCuts	(	const MuPatTrack &	entry1,
		const MuPatSegment &	entry2,
		bool	useTightCuts ) const

Definition at line 328 of file MooCandidateMatchingTool.cxx.

                                                                                             {
        TrackSegmentMatchCuts cuts;
        cuts.useTightCuts = useTightCuts;
        cuts.posXCut = m_matchPosXCut;
        cuts.posYCut = m_matchPosYCut;
        cuts.posXPullCut = m_matchPosPullCut;
        cuts.posYPullCut = m_matchPosPullCut;
        cuts.angleXCut = m_matchAngXCut;
        cuts.angleYCut = m_matchAngYCut;
        cuts.angleXPullCut = m_matchAngXPullCut;
        cuts.angleYPullCut = m_matchAngYPullCut;
        if (useTightCuts) {
            cuts.matchChiSquaredCut = m_matchChiSquaredCutTight;
        } else {
            cuts.matchChiSquaredCut = m_matchChiSquaredCut;
        }
 
        cuts.cutOnMatchChiSquared = true;
        if (entry2.containsChamber(MuonStationIndex::ChIndex::CSS) || 
            entry2.containsChamber(MuonStationIndex::ChIndex::CSL)) {
            // CSC
            cuts.cutOnPosX = true;
            cuts.cutOnPosY = true;
            cuts.cutOnPosXPull = true;
            cuts.cutOnPosYPull = true;
            cuts.cutOnAngleX = true;
            cuts.cutOnAngleY = true;
            cuts.cutOnAngleXPull = true;
            cuts.cutOnAngleYPull = true;
        } else {  // ! containsChamber(CSS || CSL)
            // MDT
            cuts.cutOnPosX = false;
            cuts.cutOnPosY = true;
            cuts.cutOnPosXPull = false;
            cuts.cutOnPosYPull = true;
            cuts.cutOnAngleX = false;
            cuts.cutOnAngleY = true;
            cuts.cutOnAngleXPull = false;
            cuts.cutOnAngleYPull = true;
        }
 
        if (cuts.posXCut == 0.0) cuts.cutOnPosX = false;
        if (cuts.posYCut == 0.0) cuts.cutOnPosY = false;
        if (cuts.angleXCut == 0.0) cuts.cutOnAngleX = false;
        if (cuts.angleYCut == 0.0) cuts.cutOnAngleY = false;
        if (cuts.posXPullCut == 0.0) cuts.cutOnPosXPull = false;
        if (cuts.posYPullCut == 0.0) cuts.cutOnPosYPull = false;
        if (cuts.angleXPullCut == 0.0) cuts.cutOnAngleXPull = false;
        if (cuts.angleYPullCut == 0.0) cuts.cutOnAngleYPull = false;
        if (cuts.matchChiSquaredCut == 0.0) cuts.cutOnMatchChiSquared = false;
 
        return cuts;
    }

initialize()

StatusCode Muon::MooCandidateMatchingTool::initialize ( )

overridevirtual

initialize method, method taken from bass-class AlgTool

Definition at line 99 of file MooCandidateMatchingTool.cxx.

                                                    {
        ATH_CHECK(m_atlasExtrapolator.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
        ATH_CHECK(m_segmentMatchingTool.retrieve());
        ATH_CHECK(m_segmentMatchingToolTight.retrieve());
        ATH_CHECK(m_candidateTool.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.

interfaceID()

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

inlinestatic

access to tool interface

Definition at line 62 of file MooCandidateMatchingTool.h.

                                                {
            static const InterfaceID IID_MooCandidateMatchingTool("Muon::MooCandidateMatchingTool", 1, 0);
            return IID_MooCandidateMatchingTool;
        }

match() [1/4]

bool Muon::MooCandidateMatchingTool::match	(	const EventContext &	ctx,
		const MuPatCandidateBase &	entry1,
		const MuPatSegment &	entry2,
		bool	useTightCuts ) const

match a segment entry with a base entry

Definition at line 1167 of file MooCandidateMatchingTool.cxx.

                                                                                                                                                       {
        const MuPatSegment* seg = dynamic_cast<const MuPatSegment*>(&entry1);
        if (seg) return match(ctx, *seg, entry2, useTightCuts);
 
        const MuPatTrack* track = dynamic_cast<const MuPatTrack*>(&entry1);
        if (track) return match(ctx, *track, entry2, useTightCuts);
 
        return false;
    }

match() [2/4]

bool Muon::MooCandidateMatchingTool::match	(	const EventContext &	ctx,
		const MuPatSegment &	entry1,
		const MuPatSegment &	entry2,
		bool	useTightCuts ) const

match two segment entries

Definition at line 171 of file MooCandidateMatchingTool.cxx.

                                                                                                                                                 {
        ++m_segmentMatches;
 
        // same segments should never be matched!
        if (&entry1 == &entry2) {
            ATH_MSG_DEBUG("Matching segment with itself: " << entry1.name << ". Should not happen!. Returning false.");
            return false;
        }
 
        // check whether SL overlap => same station index, just one station
        bool isSLOverlap = false;
        if (entry1.stations().size() == 1 && entry2.stations().size() == 1 && entry1.stations().count(*entry2.stations().begin()))
            isSLOverlap = true;
        if (isSLOverlap) {
            ATH_MSG_DEBUG("Small/large overlap");
            // don't combine CSC and MDT segments
            if (entry1.isMdt != entry2.isMdt) {
                ATH_MSG_DEBUG(" mdt/csc mix ignored");
                return false;
            }
 
            if (!areInNeighbouringChambers(entry1, entry2)) {
                ATH_MSG_DEBUG(" not in neighbouring chambers");
                return false;
            }
 
            if (!checkSegmentDistance(entry1, entry2)) {
                ATH_MSG_DEBUG(" distance between segments too large");
                return false;
            }
 
            // check whether there are hits in the same chamber layer
            std::vector<MuonStationIndex::ChIndex> intersection;
            std::set_intersection(entry1.chambers().begin(), entry1.chambers().end(), entry2.chambers().begin(), entry2.chambers().end(),
                                  std::back_inserter(intersection));
 
            if (!intersection.empty()) {
                ATH_MSG_DEBUG(" Segments are in the same chamber ");
                return false;
            }
 
            if (m_idHelperSvc->issTgc(*entry1.chamberIds().begin()) || m_idHelperSvc->isMM(*entry1.chamberIds().begin())) { return true; }
        }
 
        ATH_MSG_VERBOSE("Matching segments: " << entry1.name << " and " << entry2.name);
 
        if (useTightCuts) ++m_segmentMatchesTight;
 
        if (m_requireSameSide && !sameSide(entry1, entry2, m_requireSameSide)) {
            ++m_otherSideOfPerigee;
            return false;
        } else {
            ++m_sameSideOfPerigee;
        }
 
        // call segment matching tool
        bool match = true;
        if (useTightCuts) {
            match = m_segmentMatchingToolTight->match(ctx, *entry1.segment, *entry2.segment);
        } else {
            match = m_segmentMatchingTool->match(ctx, *entry1.segment, *entry2.segment);
        }
        if (match) {
            ++m_goodSegmentMatches;
            if (useTightCuts) ++m_goodSegmentMatchesTight;
        }
 
        return match;
    }

match() [3/4]

bool Muon::MooCandidateMatchingTool::match	(	const EventContext &	ctx,
		const MuPatTrack &	entry1,
		const MuPatSegment &	entry2,
		bool	useTightCuts ) const

match a segment entry with a track entry

Definition at line 263 of file MooCandidateMatchingTool.cxx.

                                                                                                                                               {
        ++m_segmentTrackMatches;
        if (useTightCuts) ++m_segmentTrackMatchesTight;
 
        ATH_MSG_VERBOSE("Matching track: " << entry1.segmentNames() << " with segment: " << entry2.name);
 
        if (m_requireSameSide && !sameSide(entry1, entry2, m_requireSameSide)) {
 
            ++m_otherSideOfPerigeeTrk;
            return false;
        } else {
            ++m_sameSideOfPerigeeTrk;
        }
 
        // pre-matching using segment-segment matching
        // 0=no segments match,1=any segment match,2=all segment match
 
        // First pass filtering: call segment matching tool for all segment on candidate
        bool haveMatch = true;
        if (m_trackSegmentPreMatchingStrategy > 0) {
            bool haveAllMatch = true;
            bool haveAnyMatch = false;
            const std::vector<MuPatSegment*>& segments = entry1.segments();
            for (const MuPatSegment* segment : segments) {
                if (!match(ctx, *segment, entry2, false)) {
                    haveAllMatch = false;
                } else {
                    haveAnyMatch = true;
                }
            }
            if (m_trackSegmentPreMatchingStrategy == 1) {
                haveMatch = haveAnyMatch;
            } else if (m_trackSegmentPreMatchingStrategy == 2) {
                haveMatch = haveAllMatch;
            }
 
            if (!haveMatch) {
                ATH_MSG_VERBOSE("track-segment match: -> Failed in comparing segments on track");
 
                ++m_reasonsForMatchNotOk[TrackSegmentMatchResult::SegmentMatch];
                return false;
            }
        }
 
        if (m_doTrackSegmentMatching) {
            MooTrackSegmentMatchResult info;
            calculateTrackSegmentMatchResult(ctx, entry1, entry2, info);
            TrackSegmentMatchCuts cuts = getMatchingCuts(entry1, entry2, useTightCuts);
            haveMatch = applyTrackSegmentCuts(ctx, info, cuts);
            // update counters
            if (haveMatch) {
                ++m_reasonsForMatchOk[info.reason];
            } else {
                ++m_reasonsForMatchNotOk[info.reason];
            }
        }
 
        if (haveMatch) {
            ++m_goodSegmentTrackMatches;
            if (useTightCuts) ++m_goodSegmentTrackMatchesTight;
        }
 
        return haveMatch;
    }

match() [4/4]

bool Muon::MooCandidateMatchingTool::match ( const EventContext & ctx, const Trk::Track & track, const MuonSegment & segment, bool useTightCuts ) const

overridevirtual

match a track with a segment

Implements Muon::IMuonTrackSegmentMatchingTool.

Definition at line 241 of file MooCandidateMatchingTool.cxx.

                                                                                                                                            {
        ATH_MSG_DEBUG("Match track/segment: useTightCuts " << useTightCuts);
        // convert segment and track
        std::unique_ptr<Trk::Track> inTrack = std::make_unique<Trk::Track>(track);
        std::unique_ptr<MuPatTrack> candidate = m_candidateTool->createCandidate(inTrack);
        if (!candidate) {
            ATH_MSG_VERBOSE("Failed to create track candidate");
            return false;
        }
        std::unique_ptr<MuPatSegment> segInfo(m_candidateTool->createSegInfo(ctx, segment));
        if (!segInfo) {
            ATH_MSG_VERBOSE("Failed to create segment candidate");
            return false;
        }
 
        // call match
        const bool ok = match(ctx, *candidate, *segInfo, useTightCuts);
        ATH_MSG_DEBUG("Match track/segment: result " << ok);
        // return result
        return ok;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sameSide() [1/4]

bool Muon::MooCandidateMatchingTool::sameSide	(	const Amg::Vector3D &	dir,
		const Amg::Vector3D &	pos1,
		const Amg::Vector3D &	pos2,
		bool	requireSameSideOfPerigee ) const

check whether two positions are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.

not crossing calo).

requireSameSideOfPerigee : True : require the segments to be on same side of perigee False : require the segments to be on same side of calorimeter

Definition at line 1113 of file MooCandidateMatchingTool.cxx.

                                                                                 {
        // check if segments are on same side of the Perigee in the xy plane
        Amg::Vector3D dirxy{dir.x(),dir.y(), 0.};
        dirxy = dirxy.unit();
        double distFromPerigee1 = pos1.dot(dirxy);
        double distFromPerigee2 = pos2.dot(dirxy);
        bool sameSideOfPerigee = (distFromPerigee1 * distFromPerigee2 > 0.);
        bool same = sameSideOfPerigee;
 
        // if one segment in each endcap, then consider on different side
        bool inOppositeEndcap = false;
        constexpr double etaEndcap = 1.1;
        double eta1 = pos1.eta();
        double eta2 = pos2.eta();
        if ((eta1 > +etaEndcap && eta2 < -etaEndcap) || (eta1 < -etaEndcap && eta2 > +etaEndcap)) {
            inOppositeEndcap = true;
            same = false;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::DEBUG) << MSG::VERBOSE << "sameSide: Require same side of Perigee: " << requireSameSideOfPerigee;
            double sign1 = pos1.y() < 0 ? -1. : 1.;
            double sign2 = pos2.y() < 0 ? -1. : 1.;
            msg(MSG::DEBUG) << " Direction " << dir << std::fixed << std::setprecision(0) << std::endl
                            << " pos1: dist " << std::setw(6) << distFromPerigee1 << " r " << std::setw(6) << pos1.perp() * sign1
                            << " (x,y,z)=(" << std::setw(5) << pos1.x() << "," << std::setw(5) << pos1.y() << "," << std::setw(5)
                            << pos1.z() << ")" << std::endl
                            << " pos2: dist " << std::setw(6) << distFromPerigee2 << " r " << std::setw(6) << pos2.perp() * sign2
                            << " (x,y,z)=(" << std::setw(5) << pos2.x() << "," << std::setw(5) << pos2.y() << "," << std::setw(5)
                            << pos2.z() << ")" << std::setprecision(6);  // back to default
 
            if (sameSideOfPerigee) {
                msg(MSG::DEBUG) << std::endl << " Same side of perigee.";
            } else {
                msg(MSG::DEBUG) << std::endl << " Other side of perigee.";
            }
            if (inOppositeEndcap) { msg(MSG::DEBUG) << " In opposite end-cap."; }
        }
 
        // if segments are on the same side of the Perigee, they are also on the same side of Calo, so can return
        if (same) {
            if (msgLvl(MSG::VERBOSE)) msg(MSG::DEBUG) << " => Accepted" << endmsg;
            return true;
        }
 
        // if requiring sameSideOfPerigee (stronger condition), then we are done here.
        if (requireSameSideOfPerigee) {
            if (msgLvl(MSG::VERBOSE)) msg(MSG::DEBUG) << " => Rejected" << endmsg;
            return false;
        }
        return true;
    }

sameSide() [2/4]

bool Muon::MooCandidateMatchingTool::sameSide	(	const MuPatSegment &	entry1,
		const MuPatSegment &	entry2,
		bool	requireSameSideOfPerigee ) const

check whether two segments are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.

not crossing calo).

requireSameSideOfPerigee : True : require the segments to be on same side of perigee False : require the segments to be on same side of calorimeter

Definition at line 1095 of file MooCandidateMatchingTool.cxx.

                                                                                                                                {
        ATH_MSG_VERBOSE("sameSide:  MuPatSegment, MuPatSegment");
        return sameSide(entry1.entryPars().momentum().unit(), 
                        entry1.entryPars().position(),
                        entry2.entryPars().position(), sameSideOfPerigee);
    }

sameSide() [3/4]

bool Muon::MooCandidateMatchingTool::sameSide	(	const MuPatTrack &	entry1,
		const MuPatSegment &	entry2,
		bool	requireSameSideOfPerigee ) const

Check whether the track and segment are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.

not crossing calo).

requireSameSideOfPerigee : True : require the segments to be on same side of perigee False : require the segments to be on same side of calorimeter

Definition at line 1102 of file MooCandidateMatchingTool.cxx.

                                                                                                                              {
        ATH_MSG_VERBOSE("sameSide:  MuPatTrack, MuPatSegment");
        return sameSide(entry1.entryPars().momentum().unit(), entry1.entryPars().position(), entry2.entryPars().position(),
                        sameSideOfPerigee);
    }

sameSide() [4/4]

bool Muon::MooCandidateMatchingTool::sameSide	(	const MuPatTrack &	entry1,
		const MuPatTrack &	entry2,
		bool	requireSameSideOfPerigee ) const

check whether the two tracks are on the same side of the point of closest approach to the perigee of the connecting track, or on the same side of the calorimeter (i.e.

not crossing calo).

requireSameSideOfPerigee : True : require the segments to be on same side of perigee False : require the segments to be on same side of calorimeter

Definition at line 1108 of file MooCandidateMatchingTool.cxx.

                                                                                                                            {
        ATH_MSG_VERBOSE("sameSide:  MuPatTrack, MuPatTrack");
        return sameSide(entry1.entryPars().momentum().unit(), entry1.entryPars().position(), entry2.entryPars().position(),
                        sameSideOfPerigee);
    }

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_alignErrorAngleX

double Muon::MooCandidateMatchingTool::m_alignErrorAngleX

private

Definition at line 165 of file MooCandidateMatchingTool.h.

m_alignErrorAngleY

double Muon::MooCandidateMatchingTool::m_alignErrorAngleY

private

Definition at line 166 of file MooCandidateMatchingTool.h.

m_alignErrorPosX

double Muon::MooCandidateMatchingTool::m_alignErrorPosX

private

Definition at line 163 of file MooCandidateMatchingTool.h.

m_alignErrorPosY

double Muon::MooCandidateMatchingTool::m_alignErrorPosY

private

Definition at line 164 of file MooCandidateMatchingTool.h.

m_atlasExtrapolator

ToolHandle<Trk::IExtrapolator> Muon::MooCandidateMatchingTool::m_atlasExtrapolator

private

Initial value:

{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator",
                                                           "curved extrapolator"}

Definition at line 176 of file MooCandidateMatchingTool.h.

                                                        {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator",
                                                           "curved extrapolator"};

m_caloMatchZ

double Muon::MooCandidateMatchingTool::m_caloMatchZ

private

Z position of calo end-cap disks.

Used to determine if segments are on same side of Calo

Definition at line 208 of file MooCandidateMatchingTool.h.

m_candidateTool

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

private

Definition at line 182 of file MooCandidateMatchingTool.h.

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

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_doTrackSegmentMatching

Gaudi::Property<bool> Muon::MooCandidateMatchingTool::m_doTrackSegmentMatching {this, "DoTrackSegmentMatching", false, "Apply dedicated track-segment matching"}

private

Definition at line 190 of file MooCandidateMatchingTool.h.

{this, "DoTrackSegmentMatching", false, "Apply dedicated track-segment matching"};

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MooCandidateMatchingTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 171 of file MooCandidateMatchingTool.h.

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

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fieldCacheCondObjInputKey

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

private

Initial value:

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

Definition at line 185 of file MooCandidateMatchingTool.h.

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

m_goodSegmentMatches

std::atomic_ulong Muon::MooCandidateMatchingTool::m_goodSegmentMatches {0}

mutableprivate

matching counters

Definition at line 193 of file MooCandidateMatchingTool.h.

{0};

m_goodSegmentMatchesTight

std::atomic_ulong Muon::MooCandidateMatchingTool::m_goodSegmentMatchesTight {0}

mutableprivate

Definition at line 194 of file MooCandidateMatchingTool.h.

{0};

m_goodSegmentTrackMatches

std::atomic_ulong Muon::MooCandidateMatchingTool::m_goodSegmentTrackMatches {0}

mutableprivate

Definition at line 197 of file MooCandidateMatchingTool.h.

{0};

m_goodSegmentTrackMatchesTight

std::atomic_ulong Muon::MooCandidateMatchingTool::m_goodSegmentTrackMatchesTight {0}

mutableprivate

Definition at line 198 of file MooCandidateMatchingTool.h.

{0};

m_idHelperSvc

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

private

Definition at line 170 of file MooCandidateMatchingTool.h.

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

m_matchAngXCut

double Muon::MooCandidateMatchingTool::m_matchAngXCut

private

Definition at line 156 of file MooCandidateMatchingTool.h.

m_matchAngXPullCut

double Muon::MooCandidateMatchingTool::m_matchAngXPullCut

private

Definition at line 158 of file MooCandidateMatchingTool.h.

m_matchAngYCut

double Muon::MooCandidateMatchingTool::m_matchAngYCut

private

Definition at line 157 of file MooCandidateMatchingTool.h.

m_matchAngYPullCut

double Muon::MooCandidateMatchingTool::m_matchAngYPullCut

private

Definition at line 159 of file MooCandidateMatchingTool.h.

m_matchChiSquaredCut

double Muon::MooCandidateMatchingTool::m_matchChiSquaredCut

private

Definition at line 167 of file MooCandidateMatchingTool.h.

m_matchChiSquaredCutTight

double Muon::MooCandidateMatchingTool::m_matchChiSquaredCutTight

private

Definition at line 168 of file MooCandidateMatchingTool.h.

m_matchPosPullCut

double Muon::MooCandidateMatchingTool::m_matchPosPullCut

private

Definition at line 162 of file MooCandidateMatchingTool.h.

m_matchPosXCut

double Muon::MooCandidateMatchingTool::m_matchPosXCut

private

Definition at line 160 of file MooCandidateMatchingTool.h.

m_matchPosYCut

double Muon::MooCandidateMatchingTool::m_matchPosYCut

private

Definition at line 161 of file MooCandidateMatchingTool.h.

m_minimumSideMatchRadius

double Muon::MooCandidateMatchingTool::m_minimumSideMatchRadius

private

Definition at line 155 of file MooCandidateMatchingTool.h.

m_otherSideOfPerigee

std::atomic_ulong Muon::MooCandidateMatchingTool::m_otherSideOfPerigee {0}

mutableprivate

Definition at line 200 of file MooCandidateMatchingTool.h.

{0};

m_otherSideOfPerigeeTrk

std::atomic_ulong Muon::MooCandidateMatchingTool::m_otherSideOfPerigeeTrk {0}

mutableprivate

Definition at line 202 of file MooCandidateMatchingTool.h.

{0};

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MooCandidateMatchingTool::m_printer

private

Initial value:

{this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                 "tool to print EDM objects"}

Definition at line 174 of file MooCandidateMatchingTool.h.

                                                      {this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                 "tool to print EDM objects"};

m_reasonsForMatchNotOk

std::atomic_ulong Muon::MooCandidateMatchingTool::m_reasonsForMatchNotOk[TrackSegmentMatchResult::NumberOfReasons] {0}

mutableprivate

Definition at line 206 of file MooCandidateMatchingTool.h.

{0};

m_reasonsForMatchOk

std::atomic_ulong Muon::MooCandidateMatchingTool::m_reasonsForMatchOk[TrackSegmentMatchResult::NumberOfReasons] {0}

mutableprivate

Definition at line 205 of file MooCandidateMatchingTool.h.

{0};

m_requireSameSide

bool Muon::MooCandidateMatchingTool::m_requireSameSide

private

require entries to be on the same side of the Perigee or Calorimeter

Definition at line 211 of file MooCandidateMatchingTool.h.

m_sameSideOfPerigee

std::atomic_ulong Muon::MooCandidateMatchingTool::m_sameSideOfPerigee {0}

mutableprivate

Definition at line 199 of file MooCandidateMatchingTool.h.

{0};

m_sameSideOfPerigeeTrk

std::atomic_ulong Muon::MooCandidateMatchingTool::m_sameSideOfPerigeeTrk {0}

mutableprivate

Definition at line 201 of file MooCandidateMatchingTool.h.

{0};

m_segmentMatches

std::atomic_ulong Muon::MooCandidateMatchingTool::m_segmentMatches {0}

mutableprivate

Definition at line 195 of file MooCandidateMatchingTool.h.

{0};

m_segmentMatchesTight

std::atomic_ulong Muon::MooCandidateMatchingTool::m_segmentMatchesTight {0}

mutableprivate

Definition at line 196 of file MooCandidateMatchingTool.h.

{0};

m_segmentMatchingTool

ToolHandle<IMuonSegmentMatchingTool> Muon::MooCandidateMatchingTool::m_segmentMatchingTool

private

Initial value:

{this, "SegmentMatchingTool",
                                                                   "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingTool"}

Definition at line 178 of file MooCandidateMatchingTool.h.

                                                                  {this, "SegmentMatchingTool",
                                                                   "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingTool"};

m_segmentMatchingToolTight

ToolHandle<IMuonSegmentMatchingTool> Muon::MooCandidateMatchingTool::m_segmentMatchingToolTight

private

Initial value:

{this, "SegmentMatchingToolTight",
                                                                        "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingToolTight"}

Definition at line 180 of file MooCandidateMatchingTool.h.

                                                                       {this, "SegmentMatchingToolTight",
                                                                        "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingToolTight"};

m_segmentTrackMatches

std::atomic_ulong Muon::MooCandidateMatchingTool::m_segmentTrackMatches {0}

mutableprivate

Definition at line 203 of file MooCandidateMatchingTool.h.

{0};

m_segmentTrackMatchesTight

std::atomic_ulong Muon::MooCandidateMatchingTool::m_segmentTrackMatchesTight {0}

mutableprivate

Definition at line 204 of file MooCandidateMatchingTool.h.

{0};

m_trackSegmentPreMatchingStrategy

Gaudi::Property<int> Muon::MooCandidateMatchingTool::m_trackSegmentPreMatchingStrategy

private

Initial value:

{this, "TrackSegmentPreMatching", 0,
                                                               "0=no segments match,1=any segment match,2=all segment match"}

Definition at line 188 of file MooCandidateMatchingTool.h.

                                                            {this, "TrackSegmentPreMatching", 0,
                                                               "0=no segments match,1=any segment match,2=all segment match"};

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:

• MooCandidateMatchingTool.h
• MooCandidateMatchingTool.cxx