MuonTrackPerformanceAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONTRACKPERFORMANCEALG_H
#define MUONTRACKPERFORMANCEALG_H
 
#include <fstream>
#include <iostream>
#include <set>
#include <string>
#include <vector>
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GeneratorObjects/McEventCollection.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMuonTrackTruthTool.h"
#include "MuonSimData/CscSimDataCollection.h"
#include "MuonSimData/MuonSimDataCollection.h"
#include "StoreGate/ReadHandleKey.h"
#include "TrackRecord/TrackRecordCollection.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkToolInterfaces/ITrackSummaryHelperTool.h"
#include "TrkTrack/TrackCollection.h"
#include "TrkTrackSummary/MuonTrackSummary.h"
#include "TrkTrackSummary/TrackSummary.h"
#include "TrkTruthData/TruthTrajectory.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODMuon/MuonContainer.h"
 
class TFile;
class TruthTrajectory;
 
#include "AtlasHepMC/GenParticle_fwd.h"
 
namespace Trk {
    class Track;
    class TrackSummary;
}  // namespace Trk
 
namespace Muon {
    class MuonSegmentCombination;
    class MuonSegment;
}  // namespace Muon
 
class MuonTrackPerformanceAlg : public AthAlgorithm {
public:
    struct ChamberData {
        Identifier chId{};
        std::set<Identifier> hits;
    };
 
    struct TrackData {
        TrackData() :
            truthTrack(nullptr),
            motherPdg(-1),
            chi2Ndof(0.),
            productionVertex(nullptr),
            momentumAtProduction(nullptr),
            truthTrajectory(nullptr),
            trackPars(nullptr),
            trackSummary(nullptr) {}
 
        ~TrackData() {
            delete trackPars;
            delete trackSummary;
            delete truthTrack;
            delete truthTrajectory;
            delete productionVertex;
            delete momentumAtProduction;
        }
 
        TrackData(const TrackData& data) {
            motherPdg = data.motherPdg;
            chi2Ndof = data.chi2Ndof;
            trackPars = data.trackPars ? new Trk::Perigee(*data.trackPars) : 0;
            trackSummary = data.trackSummary ? new Trk::TrackSummary(*data.trackSummary) : 0;
            truthTrack = data.truthTrack ? new TrackRecord(*data.truthTrack) : 0;
            productionVertex = data.productionVertex ? new Amg::Vector3D(*data.productionVertex) : 0;
            momentumAtProduction = data.momentumAtProduction ? new Amg::Vector3D(*data.momentumAtProduction) : 0;
        }
         // no copying
        TrackData& operator=(const TrackData&) = delete;
 
        TrackRecord* truthTrack{};
        int motherPdg{};
        double chi2Ndof{};
        Amg::Vector3D* productionVertex{};
        Amg::Vector3D* momentumAtProduction{};
        TruthTrajectory* truthTrajectory{};
        Trk::Perigee* trackPars{};
        Trk::TrackSummary* trackSummary{};
 
        std::vector<ChamberData> missingChambers;
        std::vector<ChamberData> wrongChambers;
 
        std::set<Muon::MuonStationIndex::StIndex> layers;
        std::set<Muon::MuonStationIndex::StIndex> missingLayers;
        std::set<Muon::MuonStationIndex::StIndex> missingCscLayers;
        std::set<Muon::MuonStationIndex::StIndex> wrongLayers;
 
        std::set<Muon::MuonStationIndex::StIndex> layersTrigger;
        std::set<Muon::MuonStationIndex::StIndex> missingLayersTrigger;
        std::set<Muon::MuonStationIndex::StIndex> wrongLayersTrigger;
 
        bool isEndcapSLTrack() const {
            if (layers.size() == 1 && layers.count(Muon::MuonStationIndex::EM)) return true;
            if (layers.size() == 2 && layers.count(Muon::MuonStationIndex::EM) && layers.count(Muon::MuonStationIndex::EO)) return true;
            return false;
        }
 
        bool hasMissingChambers() const { return !missingChambers.empty(); }
 
        bool hasWrongChambers() const { return !wrongChambers.empty(); }
 
        bool hasMissingLayers() const { return !missingLayers.empty(); }
 
        bool hasWrongLayers() const { return !wrongLayers.empty(); }
 
        bool hasMissingLayersTrigger() const { return !missingLayersTrigger.empty(); }
 
        bool hasWrongLayersTrigger() const { return !wrongLayersTrigger.empty(); }
 
        bool isMissingInner() const {
            if (missingLayers.count(Muon::MuonStationIndex::EI) || missingLayers.count(Muon::MuonStationIndex::BI)) return true;
            return false;
        }
 
        bool hasWrongInner() const {
            if (wrongLayers.count(Muon::MuonStationIndex::EI) || wrongLayers.count(Muon::MuonStationIndex::BI)) return true;
            return false;
        }
 
        bool allOk() const {
            if (!missingChambers.empty() || !wrongChambers.empty()) return false;
            if (!missingLayers.empty() || !wrongLayers.empty()) return false;
            if (!missingLayersTrigger.empty() || !wrongLayersTrigger.empty()) return false;
            return true;
        }
 
    private:
       
    };
 
    struct EventData {
        unsigned int eventNumber{};
        unsigned int eventPosition{};
        std::vector<TrackData*> missingTruthTracks;
        std::vector<TrackData*> missingTruthTracksOneStation;
 
        std::vector<TrackData*> missingStationMomLoss;
 
        std::vector<TrackData*> missingStationLayer;
        std::vector<TrackData*> missingCscStationLayer;
        std::vector<TrackData*> missingStation;
 
        std::vector<TrackData*> wrongStationLayer;
        std::vector<TrackData*> wrongStation;
 
        std::vector<TrackData*> missingStationLayerTrigger;
        std::vector<TrackData*> wrongStationLayerTrigger;
 
        std::vector<TrackData*> fakeTracks;
        std::vector<TrackData*> fakeTracksLowPt;
        std::vector<TrackData*> fakeTracksSL;
 
        bool goodEvent() const {
            return missingTruthTracks.empty() && missingTruthTracksOneStation.empty() && missingStationMomLoss.empty() &&
                   missingStationLayer.empty() && missingStation.empty() && wrongStationLayer.empty() && wrongStation.empty() &&
                   fakeTracks.empty() && fakeTracksLowPt.empty() && fakeTracksSL.empty();
        }
    };
 
    MuonTrackPerformanceAlg(const std::string& name, ISvcLocator* pSvcLocator);
 
public:
    virtual ~MuonTrackPerformanceAlg();
 
    virtual StatusCode initialize() override;
    virtual StatusCode execute() override;
    virtual StatusCode finalize() override;
 
    virtual unsigned int cardinality() const override final { return 1;}
 
private:
    void extractEtaPhiCounts(const std::set<Identifier>& ids, int& neta, int& nphi, int& netaCh, int& nphiCh) const;
 
    bool handleTracks();
    bool handleTrackTruth(const TrackCollection& trackCollection);
 
    bool handleSegmentCombi(const Muon::MuonSegmentCombination& combi);
 
    void doSummary(const TrackCollection& tracks) const;
    void doSummary(const Muon::IMuonTrackTruthTool::TruthTree& truthTracks) const;
 
    std::string print(const Muon::IMuonTrackTruthTool::TruthTreeEntry& trackTruth) const;
 
    std::string eventInfo() const;
    int eventNumber() const;
 
    void printMissingChambers() const;
    void printMissingTracks() const;
    void printFakeTracks() const;
 
    std::pair<int, int> countHitsInChamber(const Identifier& chId, const std::set<Identifier>& hitIds) const;
 
    bool insertChamber(const Identifier& chId, const std::set<Identifier>& hits, int minEtaHits, int minPhiHits,
                       ChamberData& chamberData) const;
 
    bool insertTechnology(const std::set<Identifier>& chIds, const std::set<Identifier>& hits, int minEtaHits, int minPhiHits,
                          std::vector<ChamberData>& chamberData) const;
 
    bool insertStationLayers(const std::set<Identifier>& chIds, const std::set<Muon::MuonStationIndex::StIndex>& exclusionList,
                             std::set<Muon::MuonStationIndex::StIndex>& layers) const;
 
    bool insertStationLayers(const std::vector<ChamberData>& chambers, const std::set<Muon::MuonStationIndex::StIndex>& exclusionList,
                             std::set<Muon::MuonStationIndex::StIndex>& layers, bool usePrecision) const;
 
    TrackData* evaluateTrackTruthOverlap(const Muon::MuonTrackTruth& truthTrack) const;
 
    TrackData* createTrackData(const Muon::IMuonTrackTruthTool::TruthTreeEntry& trackTruth) const;
 
    void addTrackToTrackData(const Trk::Track& track, TrackData& trackData) const;
 
    std::string print(const TrackData& trackData) const;
 
    std::string print(const EventData& event, const std::vector<TrackData*>& tracks, const std::string& message) const;
    std::string print(const EventData& event, const std::vector<const Trk::Track*>& tracks, const std::string& message) const;
 
    std::string printTrackCounters(bool doSecondaries = true) const;
 
    void clearTracks(std::vector<const Trk::Track*> tracks);
    void clearTracks(std::vector<TrackData*> tracks);
    void clearEvent(EventData& event);
 
    HepMC::ConstGenParticlePtr getMother(const TruthTrajectory& traj) const;
    HepMC::ConstGenParticlePtr getInitialState(const TruthTrajectory& traj) const;
 
    bool goodTruthTrack(const Muon::IMuonTrackTruthTool::TruthTreeEntry& entry) const;
    bool isSecondary(const Muon::MuonTrackTruth& truthTrack) const;
    bool isSecondary(const Muon::IMuonTrackTruthTool::TruthTreeEntry& entry) const;
    bool isSecondary(const TruthTrajectory& truthTrajectory) const;
 
    bool selectPdg(int pdg) const { return m_selectedPdgs.count(pdg); }
 
    SG::ReadHandleKey<TrackCollection> m_trackKey{this, "TrackInputLocation", "MuonSpectrometerTracks",
                                                  "input tracks"};                                 
    SG::ReadHandleKey<xAOD::MuonContainer> m_muons{this, "MuonLocation", "Muons", "input muons"};  // muons for cases other than MS tracks
    SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey{this, "EventInfoKey", "EventInfo", "EventInfo key"};
    const xAOD::EventInfo* m_eventInfo;  
 
    // truth readHandles
    SG::ReadHandleKey<McEventCollection> m_mcEventColl{this, "McEventCollectionKey", "TruthEvent", "McEventCollection"};
    SG::ReadHandleKeyArray<MuonSimDataCollection> m_muonSimData{
        this, "MuonSimDataNames", {"MDT_SDO", "RPC_SDO", "TGC_SDO", "sTGC_SDO", "MM_SDO"}, "Muon SDO maps"};
    SG::ReadHandleKey<CscSimDataCollection> m_cscSimData{this, "CSC_SDO_Container", "CSC_SDO", "CSC SDO"};
    SG::ReadHandleKey<TrackRecordCollection> m_trackRecord{this, "TrackRecord", "MuonEntryLayerFilter", "Track Record Collection"};
 
    // member set by Joboptions
    int m_doSummary{};
    int m_doHitResiduals{};
    int m_doTrackDebug{};
    bool m_doTruth{};
    bool m_doHistos{};
    double m_momentumCutSim{};
    double m_momentumCut{};
    bool m_usePtCut{};
    bool m_isCombined{};
    bool m_doSegments{};
    bool m_writeToFile{};
    bool m_doStau{};
 
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
    
    PublicToolHandle<Muon::MuonEDMPrinterTool> m_printer{this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};
 
    ServiceHandle<Muon::IMuonEDMHelperSvc> m_edmHelperSvc{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"};
    
    
    ToolHandle<Muon::IMuonTrackTruthTool> m_truthTool{this, "TrackTruthTool",""};
    ToolHandle<Trk::ITrackSummaryHelperTool> m_summaryHelperTool{this, "SummaryHelperTool", ""};
    int m_doEventListMissed{};
    int m_doEventListIncomplete{};
    int m_doEventListFake{};
 
    int m_minMdtHits{};
    int m_minCscEtaHits{};
    int m_minCscPhiHits{};
    int m_minRpcEtaHits{};
    int m_minRpcPhiHits{};
    int m_minTgcEtaHits{};
    int m_minTgcPhiHits{};
    int m_minsTgcEtaHits{};
    int m_minsTgcPhiHits{};
    int m_minMMEtaHits{};
 
    unsigned int m_nevents{};
    unsigned int m_ntracks{};
 
    unsigned int m_nmatchedTracks{};
    unsigned int m_nmatchedTracksSecondary{};
    unsigned int m_nmatchedFakeTracks{};
 
    unsigned int m_nfakeTracks{};
    unsigned int m_nfakeTracksHighPt{};
    unsigned int m_nfakeTracksLowPt{};
    unsigned int m_nfakeTracksSL{};
 
    unsigned int m_nmissedTracks{};
    unsigned int m_nmissedTracksOneStation{};
 
    unsigned int m_nmissedTracksSecondary{};
    unsigned int m_nmissedTracksOneStationSecondary{};
 
    unsigned int m_nmissingStationMomLoss{};
    unsigned int m_nmissingStationLayer{};
    unsigned int m_nmissingCscStationLayer{};
    unsigned int m_nmissingStationLayerTrigger{};
    unsigned int m_nmissingStation{};
 
    unsigned int m_nwrongStationLayer{};
    unsigned int m_nwrongStationLayerTrigger{};
    unsigned int m_nwrongStation{};
 
    unsigned int m_ntruthTracks{};
    unsigned int m_ntruthTracksSecondary{};
 
    struct TrackSummary {
        std::string trackPars;
        std::string chambers;
        std::vector<std::string> missingChambers;
    };
 
    struct EventSummary {
        std::string eventNumber;
        std::vector<TrackSummary> trackSummary;
    };
 
    void printSummary(const std::vector<EventSummary>& summary, std::string typeName) const;
 
    std::vector<EventData> m_badEvents;
 
    std::string m_fileName;
 
    std::ofstream m_fileOutput;
 
    IntegerArrayProperty m_pdgsToBeConsidered;
    std::set<int> m_selectedPdgs;  // set storing particle PDG's considered for matching
 
    // type of track (based on enum defined in Muon_v1.h)
    int m_trackType{};
    std::string m_trackTypeString;
};
 
#endif  // MUONTRACKPERFORMANCEALG_H