MooTrackBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUON_MOOTRACKBUILDER_H
#define MUON_MOOTRACKBUILDER_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
// Tools & interfaces
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonErrorOptimisationTool.h"
#include "MuonRecToolInterfaces/IMuonHoleRecoveryTool.h"
#include "MuonRecToolInterfaces/IMuonSeededSegmentFinder.h"
#include "MuonRecToolInterfaces/IMuonSegmentTrackBuilder.h"
#include "MuonRecToolInterfaces/IMuonTrackBuilder.h"
#include "MuonRecToolInterfaces/IMuonTrackExtrapolationTool.h"
#include "MuonRecToolInterfaces/IMuonTrackRefiner.h"
#include "MuonRecToolInterfaces/IMuonTrackToSegmentTool.h"
#include "TrkExInterfaces/IPropagator.h"
#include "TrkToolInterfaces/IResidualPullCalculator.h"
 
// For magneticfield
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "TrkToolInterfaces/IExtendedTrackSummaryTool.h"
#include "TrkTrackSummary/MuonTrackSummary.h"
 
// Tracking EDM
#include "TrkGeometry/MagneticFieldProperties.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkSegment/SegmentCollection.h"
#include "TrkTrack/Track.h"
#include "TrkTrack/TrackCollection.h"
 
// Local
#include "MooCandidateMatchingTool.h"
#include "MooTrackFitter.h"
#include "MuPatCandidateTool.h"
 
// Misc
#include <vector>
 
class MsgStream;
 
namespace Trk {
    class Track;
    class PrepRawData;
    class IExtendedTrackSummaryTool;
}  // namespace Trk
 
namespace Muon {
    class MuonSegment;
    class MuPatCandidateBase;
    class MuPatTrack;
    class MuPatSegment;
}  // namespace Muon
 
namespace Muon {
 
    class MooTrackBuilder : virtual public IMuonSegmentTrackBuilder, public IMuonTrackBuilder, public IMuonTrackRefiner, public AthAlgTool {
       
 
    public:
        MooTrackBuilder(const std::string&, const std::string&, const IInterface*);
 
        ~MooTrackBuilder() = default;
 
        virtual StatusCode initialize() override;
 
        virtual StatusCode finalize() override;
 
        static const InterfaceID& interfaceID() {
            static const InterfaceID IID_MooTrackBuilder("Muon::MooTrackBuilder", 1, 0);
            return IID_MooTrackBuilder;
        }
 
        virtual std::unique_ptr<Trk::Track> refit(const EventContext& ctx, Trk::Track& track) const override;
    private:
        std::unique_ptr<Trk::Track> combine(const EventContext& ctx, const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry,
                                            const PrepVec& patternPhiHits) const;
        
    public:        
        std::unique_ptr<MuonSegment> combineToSegment(const EventContext& ctx, const MuPatCandidateBase& firstEntry, const MuPatCandidateBase& secondEntry,
                                      const PrepVec& patternPhiHits) const;
    
        virtual std::unique_ptr<MuonSegment> combineToSegment(const EventContext& ctx, const MuonSegment& seg1, const MuonSegment& seg2,
                                              const PrepVec& patternPhiHits) const override;
 
        virtual std::unique_ptr<Trk::Track> combine(const EventContext& ctx, const MuonSegment& seg1, const MuonSegment& seg2,
                                                    const PrepVec& patternPhiHits) const override;
 
        virtual std::unique_ptr<Trk::Track> combine(const EventContext& ctx, const Trk::Track& track, const MuonSegment& seg,
                                                    const PrepVec& patternPhiHits) const override;
 
    private:
        std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding(const EventContext& ctx, const Trk::Track& track, const MuonSegment& seg,
                                                                            const PrepVec& patternPhiHits) const;
 
        std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding(const EventContext& ctx, const MuPatTrack& candidate, 
                                                                            const MuPatSegment& segInfo, const PrepVec& patternPhiHits) const;
 
        std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding(const EventContext& ctx, const MuPatTrack& candidate, const Trk::TrackParameters& pars,
                                                                            const std::set<Identifier>& chIds, const PrepVec& patternPhiHits) const;
        std::vector<std::unique_ptr<Trk::Track> > combineWithSegmentFinding(const EventContext& ctx, const Trk::Track& track, const Trk::TrackParameters& pars,
                                                                            const std::set<Identifier>& chIds,
                                                                            const PrepVec& patternPhiHits) const;
    public:    
        virtual std::unique_ptr<Trk::TrackParameters> findClosestParameters(const Trk::Track& track, const Amg::Vector3D& pos) const override;
 
        virtual std::unique_ptr<Trk::TrackParameters> getClosestParameters(const Trk::Track& track, const Trk::Surface& surf) const override;
 
        std::unique_ptr<Trk::TrackParameters> getClosestParameters(const MuPatCandidateBase& candidate, const Trk::Surface& surf) const;
 
        virtual std::unique_ptr<Trk::Track> recalibrateHitsOnTrack(const EventContext& ctx, const Trk::Track& track, bool doMdts,
                                                                   bool doCompetingClusters) const override;
 
    private:
        std::pair<std::unique_ptr<Trk::Track>, std::unique_ptr<Trk::Track> > splitTrack(const EventContext& ctx, const Trk::Track& track) const;
 
        bool isSplitTrack(const EventContext& ctx, const Trk::Track& track1, const Trk::Track& track2) const;
 
        TrackCollection* mergeSplitTracks(const EventContext& ctx, const TrackCollection& tracks) const;
 
    public:
        virtual std::vector<std::unique_ptr<MuPatTrack> > find(const EventContext& ctx, MuPatCandidateBase& candidate, const std::vector<MuPatSegment*>& segments) const override;
 
        virtual void refine(const EventContext& ctx, MuPatTrack& track) const override;
 
    private:
        void removeDuplicateWithReference(std::unique_ptr<Trk::SegmentCollection>& segments,
                                          std::vector<const MuonSegment*>& referenceSegments) const;
 
        Trk::TrackStates::const_iterator insertClustersWithCompetingRotCreation(const EventContext& ctx,
            Trk::TrackStates::const_iterator tsit,
            Trk::TrackStates::const_iterator tsit_end,
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>>& states) const;
 
        ToolHandle<MooTrackFitter> m_fitter{this, "Fitter", "Muon::MooTrackFitter/MooTrackFitter", "Tool to fit segments to tracks"};
        ToolHandle<MooTrackFitter> m_slFitter{this, "SLFitter", "Muon::MooTrackFitter/MooSLTrackFitter", "Tool to fit segments to tracks"};
        ToolHandle<MuPatCandidateTool> m_candidateHandler{this, "CandidateTool",
                                                          "Muon::MuPatCandidateTool/MuPatCandidateTool"};  
        ToolHandle<MooCandidateMatchingTool> m_candidateMatchingTool{this, "CandidateMatchingTool",
                                                                     "Muon::MooCandidateMatchingTool/MooCandidateMatchingTool"};
        ToolHandle<IMuonTrackToSegmentTool> m_trackToSegmentTool{this, "TrackToSegmentTool",
                                                                 "Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool"};
        ServiceHandle<IMuonEDMHelperSvc> m_edmHelperSvc{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                        "Handle to the service providing the IMuonEDMHelperSvc interface"};
        PublicToolHandle<MuonEDMPrinterTool> m_printer{this, "Printer",
                                                 "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};  
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
        ToolHandle<IMuonSeededSegmentFinder> m_seededSegmentFinder{this, "SeededSegmentFinder",
                                                                   "Muon::MuonSeededSegmentFinder/MuonSeededSegmentFinder"};
        ToolHandle<IMdtDriftCircleOnTrackCreator> m_mdtRotCreator{this, "MdtRotCreator",
                                                                  "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"};
        ToolHandle<IMuonCompetingClustersOnTrackCreator> m_compRotCreator{
            this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator"};
        ToolHandle<Trk::IPropagator> m_propagator{this, "Propagator", "Trk::STEP_Propagator/MuonPropagator"};
        ToolHandle<Trk::IResidualPullCalculator> m_pullCalculator{this, "PullCalculator",
                                                                  "Trk::ResidualPullCalculator/ResidualPullCalculator"};
        ToolHandle<IMuonHoleRecoveryTool> m_muonChamberHoleRecoverTool{
            this, "ChamberHoleRecoveryTool",
            "Muon::MuonChamberHoleRecoveryTool/MuonChamberHoleRecoveryTool"};  //<! tool to add holes on track
        ToolHandle<IMuonTrackExtrapolationTool> m_trackExtrapolationTool{
            this, "Extrapolator", "Muon::MuonTrackExtrapolationTool/MuonTrackExtrapolationTool"};  //<! track extrapolation tool
 
        ToolHandle<IMuonErrorOptimisationTool> m_errorOptimisationTool{this, "ErrorOptimisationTool", ""};
        ToolHandle<Trk::IExtendedTrackSummaryTool> m_trackSummaryTool{this, "TrackSummaryTool", "MuonTrackSummaryTool"};
        // 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"};
        Trk::MagneticFieldProperties m_magFieldProperties{Trk::FullField};  
 
        Gaudi::Property<bool> m_doTimeOutChecks{this, "UseTimeOutGuard", true};  
        Gaudi::Property<bool> m_useExclusionList{this, "UseExclusionList",
                                                 true};  
        Gaudi::Property<bool> m_useTrackingHistory{this, "UseTrackingHistory",
                                                   true};  
        Gaudi::Property<bool> m_recalibrateMDTHits{this, "RecalibrateMDTHitsOnTrack", true};
        mutable std::atomic_uint m_ncalls{0};
        mutable std::atomic_uint m_nTimedOut{0};
    };
 
}  // namespace Muon
 
#endif