MuPatCandidateTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUPATCANDIDATETOOL_H
#define MUPATCANDIDATETOOL_H
 
#include <mutex>
#include <set>
#include <vector>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "MuPatHitTool.h"  // Needed to enfornce build order for reflex dict
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonClusterOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h"
#include "MuonRecToolInterfaces/IMuonSegmentInfoExtender.h"
#include "MuonSegmentMakerToolInterfaces/IMuonSegmentSelectionTool.h"
#include "MuonTrackMakerUtils/MuonTrackMakerStlTools.h"
#include "TrkParameters/TrackParameters.h"
 
class MsgStream;
 
namespace Trk {
    class Track;
    class MeasurementBase;
    class MagneticFieldProperties;
}  // namespace Trk
 
namespace MuonGM {
    class MuonReadoutElement;
}
 
namespace Muon {
 
    class MuonSegment;
    class MuPatTrack;
    class MuPatSegment;
    class MuPatCandidateBase;
    class MuonClusterOnTrack;
 
   
    class MuPatCandidateTool : public AthAlgTool {
    public:
        using MeasVec = std::vector<const Trk::MeasurementBase*>;
        typedef MeasVec::iterator MeasIt;
        typedef MeasVec::const_iterator MeasCit;
 
    public:
        MuPatCandidateTool(const std::string&, const std::string&, const IInterface*);
 
        virtual ~MuPatCandidateTool() = default;
 
        virtual StatusCode initialize() override;
 
        static const InterfaceID& interfaceID() {
             static const InterfaceID IID_MuPatCandidateTool("Muon::MuPatCandidateTool", 1, 0);
             return IID_MuPatCandidateTool; 
        }
 
        bool extendWithSegment(MuPatTrack& can, MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track) const;
 
        std::unique_ptr<MuPatTrack> createCandidate(MuPatSegment& segInfo, std::unique_ptr<Trk::Track>& track) const;
 
        std::unique_ptr<MuPatTrack> createCandidate(MuPatSegment& segInfo1, MuPatSegment& segInfo2, std::unique_ptr<Trk::Track>& track) const;
 
        std::unique_ptr<MuPatTrack> createCandidate(std::unique_ptr<Trk::Track>& track) const;
 
        bool updateTrack(MuPatTrack& candidate, std::unique_ptr<Trk::Track>& track) const;
 
        bool recalculateCandidateSegmentContent(MuPatTrack& candidate) const;
 
        static std::unique_ptr<MuPatTrack> copyCandidate(MuPatTrack* canIn) ;
 
        std::unique_ptr<MuPatSegment> createSegInfo(const EventContext& ctx, const MuonSegment& segment) const;
 
        std::set<const MuonGM::MuonReadoutElement*> readoutElements(const MuPatCandidateBase& entry) const;
 
        std::string print(const MuPatSegment& segment, int level = 0) const;
 
        std::string print(const std::vector<MuPatSegment*>& segments, int level = 0) const;
 
        std::string print(const MuPatCandidateBase& candidate, int level = 0) const;
 
        std::string print(const MuPatTrack& track, int level = 0) const;
 
        std::string print(const std::vector<std::unique_ptr<MuPatTrack> >& tracks, int level = 0) const;
 
    private:
        void updateHits(MuPatCandidateBase& entry, const MeasVec& measurements, bool recreateMDT = false,
                        bool recreateCSC = false, bool createComp = false) const;
 
        void addCluster(const Trk::MeasurementBase& meas, std::vector<const MuonClusterOnTrack*>& rots) const;
 
        void createAndAddCompetingROTs(const std::vector<const MuonClusterOnTrack*>& rots, MeasVec& hits, MeasVec& allHits,
                                       MuPatCandidateBase& entry) const;
 
        ToolHandle<IMdtDriftCircleOnTrackCreator> m_mdtRotCreator{
            this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator", "tool to calibrate MDT hits"};
        ToolHandle<IMuonClusterOnTrackCreator> m_cscRotCreator{
            this, "CscRotCreator", "Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator", "tool to calibrate CSC hits"};
        ToolHandle<IMuonCompetingClustersOnTrackCreator> m_compClusterCreator{
            this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator",
            "tool to create competing clusters on track"};
        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"};
        ToolHandle<MuPatHitTool> m_hitHandler{this, "HitTool", "Muon::MuPatHitTool/MuPatHitTool", "Tool to manipulate hit lists"};
        ToolHandle<Muon::IMuonSegmentSelectionTool> m_segmentSelector{
            this, "SegmentSelector", "Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool", "Tool to resolve track ambiguities"};
 
        Gaudi::Property<bool> m_createCompetingROTsPhi{this, "CreateCompetingROTsPhi", false};
        Gaudi::Property<bool> m_createCompetingROTsEta{this, "CreateCompetingROTsEta", true};
        Gaudi::Property<bool> m_doMdtRecreation{this, "DoMdtRecreation", false};
        Gaudi::Property<bool> m_doCscRecreation{this, "DoCscRecreation", true};
    };
 
}  // namespace Muon
 
#endif