MooCandidateMatchingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MOOCANDIDATEMATCHINGTOOL_H
#define MOOCANDIDATEMATCHINGTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkTrack/Track.h"
#include "TrkTrack/TrackStateOnSurface.h"
//
#include "CxxUtils/checker_macros.h"
#include "EventPrimitives/EventPrimitives.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MuPatCandidateTool.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMuonTrackSegmentMatchingTool.h"
#include "MuonSegmentMakerToolInterfaces/IMuonSegmentMatchingTool.h"
#include "MuonTrackMakerUtils/SortMeasurementsByPosition.h"
#include "TrkExInterfaces/IExtrapolator.h"
//
#include "MuonTrackSegmentMatchResult.h"
//
#include <array>
#include <atomic>
#include <set>
#include <string>
 
namespace Trk {
    class Track;
    class MeasurementBase;
}  // namespace Trk
 
namespace Muon {
 
    class MuonSegment;
    class MuPatTrack;
    class MuPatSegment;
    class MuPatCandidateBase;
 
    class MooCandidateMatchingTool : virtual public IMuonTrackSegmentMatchingTool, public AthAlgTool {
    public:
        struct MooTrackSegmentMatchResult : public TrackSegmentMatchResult {
            const MuPatTrack* MCTBTrack{nullptr};
            const MuPatSegment* MCTBSegment{nullptr};
 
            MooTrackSegmentMatchResult();
 
            virtual ~MooTrackSegmentMatchResult() = default;
 
            virtual void clear();
        };
        static const InterfaceID& interfaceID() {
            static const InterfaceID IID_MooCandidateMatchingTool("Muon::MooCandidateMatchingTool", 1, 0);
            return IID_MooCandidateMatchingTool;
        }
 
        MooCandidateMatchingTool(const std::string&, const std::string&, const IInterface*);
 
        virtual ~MooCandidateMatchingTool();
 
        virtual StatusCode initialize() override;
 
        virtual StatusCode finalize() override;
 
        bool match(const EventContext& ctx, const MuPatSegment& entry1, const MuPatSegment& entry2, bool useTightCuts ) const;
 
        bool match(const EventContext& ctx, const MuPatTrack& entry1, const MuPatSegment& entry2, bool useTightCuts) const;
 
        bool match(const EventContext& ctx, const MuPatCandidateBase& entry1, const MuPatSegment& entry2, bool useTightCuts) const;
 
        virtual bool match(const EventContext& ctx, const Trk::Track& track, const MuonSegment& segment, bool useTightCuts) const override;
 
        void calculateTrackSegmentMatchResult(const EventContext& ctx, const MuPatTrack& entry1, const MuPatSegment& entry2, MooTrackSegmentMatchResult& info) const;
 
        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;
 
        bool sameSide(const MuPatTrack& entry1, const MuPatSegment& entry2, bool requireSameSideOfPerigee) const;
 
        bool sameSide(const MuPatTrack& entry1, const MuPatTrack& entry2, bool requireSameSideOfPerigee) const;
 
        bool sameSide(const Amg::Vector3D& dir, const Amg::Vector3D& pos1, const Amg::Vector3D& pos2, bool requireSameSideOfPerigee) const;
 
        static void getIdentifierSet(const std::vector<const Trk::MeasurementBase*>& measurements, std::set<Identifier>& ids) ;
 
        static bool checkPhiHitConsistency(const MuPatCandidateBase& entry1, const MuPatCandidateBase& entry2) ;
 
        bool checkSegmentDistance(const MuPatSegment& entry1, const MuPatSegment& entry2) const;
 
        bool areInNeighbouringChambers(const MuPatSegment& seg1, const MuPatSegment& seg2) const;
 
    private:
        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{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                        "Handle to the service providing the IMuonEDMHelperSvc interface"};
 
        PublicToolHandle<MuonEDMPrinterTool> m_printer{this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                 "tool to print EDM objects"};
        ToolHandle<Trk::IExtrapolator> m_atlasExtrapolator{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator",
                                                           "curved extrapolator"};
        ToolHandle<IMuonSegmentMatchingTool> m_segmentMatchingTool{this, "SegmentMatchingTool",
                                                                   "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingTool"};
        ToolHandle<IMuonSegmentMatchingTool> m_segmentMatchingToolTight{this, "SegmentMatchingToolTight",
                                                                        "Muon::MuonSegmentMatchingTool/MuonSegmentMatchingToolTight"};
        ToolHandle<MuPatCandidateTool> m_candidateTool{this, "MuPatCandidateTool", "Muon::MuPatCandidateTool/MuPatCandidateTool"};
 
        // Read handle for conditions object to get the field cache
        SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheCondObjInputKey{this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"};
 
        Gaudi::Property<int> m_trackSegmentPreMatchingStrategy{this, "TrackSegmentPreMatching", 0,
                                                               "0=no segments match,1=any segment match,2=all segment match"};
        Gaudi::Property<bool> m_doTrackSegmentMatching{this, "DoTrackSegmentMatching", false, "Apply dedicated track-segment matching"};
 
        mutable std::atomic_ulong m_goodSegmentMatches{0};
        mutable std::atomic_ulong m_goodSegmentMatchesTight{0};
        mutable std::atomic_ulong m_segmentMatches{0};
        mutable std::atomic_ulong m_segmentMatchesTight{0};
        mutable std::atomic_ulong m_goodSegmentTrackMatches{0};
        mutable std::atomic_ulong m_goodSegmentTrackMatchesTight{0};
        mutable std::atomic_ulong m_sameSideOfPerigee{0};
        mutable std::atomic_ulong m_otherSideOfPerigee{0};
        mutable std::atomic_ulong m_sameSideOfPerigeeTrk{0};
        mutable std::atomic_ulong m_otherSideOfPerigeeTrk{0};
        mutable std::atomic_ulong m_segmentTrackMatches{0};
        mutable std::atomic_ulong m_segmentTrackMatchesTight{0};
        mutable std::atomic_ulong m_reasonsForMatchOk[TrackSegmentMatchResult::NumberOfReasons] {0};
        mutable std::atomic_ulong m_reasonsForMatchNotOk[TrackSegmentMatchResult::NumberOfReasons] {0};
 
        double m_caloMatchZ;  
 
        bool m_requireSameSide;  
    };
 
}  // namespace Muon
 
#endif