MuPatTrack.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUPATTRACK_H
#define MUPATTRACK_H
 
#include <mutex>
#include <set>
#include <string>
#include <vector>
 
#include "MuPatPrimitives/MuPatCandidateBase.h"
#include "MuPatPrimitives/MuPatSegment.h"
#include "MuonStationIndex/MuonStationIndex.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkTrack/Track.h"
#include "TrkEventPrimitives/TrkObjectCounter.h"
 
namespace Muon {

    class MuPatTrack : public MuPatCandidateBase, public Trk::ObjectCounter<MuPatTrack> {
        friend class MuPatCandidateTool;
 
    public:
        enum ProcessingStage {
            Unknown,
            InitialLoop,
            LayerRecovery,
            ExtendedWithSegment,
            SegmentRecovery,
            FitRemovedSegment,
            RefitRemovedSegment,
            AmbiguityCreateCandidateFromSeeds,
            AmbiguitySelectCandidates,
            MatchFail,
            FitFail,
            FitWorse,
            UnassociatedEM,
            FitRemovedLayer,
            TrackSelector,
            KeptUntilEndOfCombi,
            NumberOfProcessingStages
        };

        static const std::string& processingStageString(ProcessingStage stage);

        static unsigned int processingStageStringMaxLen();

        MuPatTrack(const std::vector<MuPatSegment*>& segments, std::unique_ptr<Trk::Track>& track, MuPatSegment* seedSeg = 0);

        MuPatTrack(MuPatSegment* segment, std::unique_ptr<Trk::Track>& track);

        MuPatTrack(MuPatSegment* segment1, MuPatSegment* segment2, std::unique_ptr<Trk::Track>& track, MuPatSegment* seedSeg = 0);

        ~MuPatTrack();

        MuPatTrack(const MuPatTrack& can);

        MuPatTrack& operator=(const MuPatTrack& can);

        Trk::Track& track() const;
        void updateTrack(std::unique_ptr<Trk::Track>& newTrack);

        const std::vector<MuPatSegment*>& segments() const;

        MuPatSegment* seedSegment() const;

        const std::vector<MuPatSegment*>& excludedSegments() const;

        void addSegment(MuPatSegment* segment, std::unique_ptr<Trk::Track>& newTrack);

        void addExcludedSegment(MuPatSegment* segment);
        bool isSegmentExcluded(const MuPatSegment* segment) const;

        const Trk::TrackParameters& entryPars() const;

        bool hasMomentum() const;

        std::vector<MuonStationIndex::StIndex> stationsInOrder();

        bool resetChambersOnCandidate(const std::set<MuonStationIndex::ChIndex>& chambers);

        std::string segmentNames() const;
 
    private:       
        //
        // private member functions
        //
        static std::vector<std::string> initProcessingStageStrings();
        static const std::vector<std::string>& processingStageStrings();

        void updateSegments(bool add);
 
    public:
        //
        // public data members
        //
        ProcessingStage created{Unknown};
        ProcessingStage lastSegmentChange{Unknown};
 
    private:       
 
        
        void modifySegmentCounters(int change);

        static bool hasMomentum(const Trk::Track& track) ;
 
        std::vector<MuPatSegment*> m_segments{};          //<! list of associated segments
        std::vector<MuPatSegment*> m_excludedSegments{};  //<! list of associated segments
        std::unique_ptr<Trk::Track> m_track{};            //<! associated track
        MuPatSegment* m_seedSeg{nullptr};                        
 
    };  // class MuPatTrack
 
 
    //
    // inline member functions implementations
    //
    inline const std::vector<MuPatSegment*>& MuPatTrack::segments() const { return m_segments; }
 
    inline MuPatSegment* MuPatTrack::seedSegment() const {
        return m_seedSeg;  // could be a null pointer - do not dereference immediately!!
    }
 
    inline const std::vector<MuPatSegment*>& MuPatTrack::excludedSegments() const { return m_excludedSegments; }
 
    inline Trk::Track& MuPatTrack::track() const { return *m_track; }
 
    inline const Trk::TrackParameters& MuPatTrack::entryPars() const {
        const Trk::Perigee* pp = m_track->perigeeParameters();
        if (pp) { return *pp; }
        assert(!m_track->trackParameters() || m_track->trackParameters()->empty());
        return *m_track->trackParameters()->front();
    }
 
    class SortMuPatTrackByQuality {
    public:
        bool operator()(const MuPatTrack* c1, const MuPatTrack* c2) {
            // prefer candidates with more segments
            if (c1->segments().size() > c2->segments().size()) return true;
            if (c1->segments().size() < c2->segments().size()) return false;
 
            // prefer tracks with fit quality (always expected)
            const Trk::FitQuality* fq1 = c1->track().fitQuality();
            const Trk::FitQuality* fq2 = c2->track().fitQuality();
            if (!fq1) return false;
            if (!fq2) return true;
 
            if (fq1->numberDoF() > fq2->numberDoF()) return true;
            if (fq1->numberDoF() < fq2->numberDoF()) return false;
 
            // select candidate with smallest chi2
            double chi2Ndof1 = fq1->chiSquared() / fq1->numberDoF();
            double chi2Ndof2 = fq2->chiSquared() / fq2->numberDoF();
            return chi2Ndof1 < chi2Ndof2;
        }
    };
 
}  // namespace Muon
 
#endif