MuonFastRecoTester.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONFASTRECONSTRUCTIONTEST_MUONFASTRECOTESTER_H
#define MUONFASTRECONSTRUCTIONTEST_MUONFASTRECOTESTER_H
 
// Framework includes
#include "AthenaBaseComps/AthHistogramAlgorithm.h"
 
// EDM includes 
#include "MuonFastRecoEvent/GlobalPattern.h"
#include <xAODMuon/Muon.h>
#include <xAODMuon/MuonContainer.h>
#include "xAODMuon/MuonSegmentContainer.h"
#include <xAODTruth/TruthParticle.h>
#include <xAODMuonSimHit/MuonSimHit.h>
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
 
// muon includes
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPRDTestR4/SpacePointTesterModule.h"
#include "MuonSpacePoint/SpacePointPerLayerSorter.h"
 
namespace MuonValR4{
 
  class MuonFastRecoTester : public AthHistogramAlgorithm {
  public:
    using AthHistogramAlgorithm::AthHistogramAlgorithm;
    virtual ~MuonFastRecoTester()  = default;
 
    virtual StatusCode initialize() override;
    virtual StatusCode execute(const EventContext& ctx) override;
    virtual StatusCode finalize() override;
 
  private:
    enum class measType {Prec, NonPrec, Phi, nTypes};
    using simHitSet = std::unordered_set<const xAOD::MuonSimHit*>;
    using TruthParticleMap = std::map<const xAOD::TruthParticle*, std::vector<simHitSet>>;
    TruthParticleMap fillTruthMap(const xAOD::MuonSegmentContainer* truthSegments,
                                  const TrigRoiDescriptorCollection* roiCollection) const;
    void fillSpacePointInfo(const MuonR4::SpacePointContainer* spc,
                            const MuonR4::GlobalPatternContainer* patternCont,
                            const TruthParticleMap& truthHits,
                            SpacePointTesterModule& spTester,
                            MuonVal::VectorBranch<unsigned char>& spTypeBranch,
                            MuonVal::MatrixBranch<unsigned char>& spMatchedToPatternBranch,
                            MuonVal::MatrixBranch<unsigned char>& spMatchedToTruthBranch) const;  
    void fillGlobPatternInfo(const MuonR4::GlobalPatternContainer* patternCont,
                             const TruthParticleMap& truthHits,
                             const std::vector<const MuonR4::SpacePointContainer*>& spContainers);
    void fillFastRecoMuonInfo(const xAOD::MuonContainer* muonCont,
                              const MuonR4::GlobalPatternContainer* patternCont);
    void fillTruthInfo(const TruthParticleMap& truthHits,
                       const std::vector<const MuonR4::SpacePointContainer*>& spContainers);
    void fillRoIInfo(const TrigRoiDescriptorCollection* roiCollection);

    enum class ePatBranchType : std::uint8_t {
        eReco,    // Counts of pattern hits
        eTruth,   // Counts of pattern hits matched to truth
        ePileup,  // Counts of pattern hits matched to pileup truth
        eMismatched, // Counts of pattern hits matched to truth but not to the main truth particle of the pattern
        eAll,     // Counts of all hits in the buckets crossed by the pattern
    };

    void updatePatHitInfo(const ePatBranchType type, 
                          const std::size_t patIdx,
                          const Muon::MuonStationIndex::StIndex hitSt,
                          const MuonR4::SpacePoint* sp,
                          const bool isSecondaryMatched = false);
                         
    // // output tree 
    MuonVal::MuonTesterTree m_tree{"MuonFastRecoTest","FastRecoTester"}; 
 
    // Space points
    SG::ReadHandleKey<MuonR4::SpacePointContainer> m_spKey{this, "SpacePointKey", "MuonSpacePoints"};
    SG::ReadHandleKey<MuonR4::SpacePointContainer> m_NSWspKey{this, "NswSpacePointKey", "NswSpacePoints"};
 
    // Global patterns
    SG::ReadHandleKey<MuonR4::GlobalPatternContainer> m_patternKey{this, "PatternKey", "R4MuonGlobalPatterns", "global pattern container"};
 
    // Fast reco muons
    SG::ReadHandleKey<xAOD::MuonContainer> m_fastMuonKey{this, "FastMuonKey", "R4FastRecoSAMuons", "fast reco muon container"};
    
    // Truth segments
    SG::ReadHandleKey<xAOD::MuonSegmentContainer> m_truthSegmentKey {this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"};
 
    // HLT seeding RoIs
    SG::ReadHandleKey<TrigRoiDescriptorCollection> m_roiCollectionKey{this, "MuRoIs", "EFMuMSReco_RoI", "Name of the input data from HLTSeeding"};
    
    ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
    
    BooleanProperty m_isMC{this, "isMC", false, "Toggle whether the job is ran on MC or not"};
 
    BooleanProperty m_isSeededReco{this, "isSeededReco", false, "Toggle whether the job is ran on seeded reconstruction or not"};
 
    BooleanProperty m_writeSpacePoints{this, "writeSpacePoints", false,
                                             "Toggle whether the particular space poitns shall be written"};
                                            
    std::shared_ptr<SpacePointTesterModule> m_spTester{};
    std::shared_ptr<SpacePointTesterModule> m_NSWspTester{};
    MuonVal::VectorBranch<unsigned char>& m_spType{m_tree.newVector<unsigned char>(m_spKey.key()+"_type")};
    MuonVal::VectorBranch<unsigned char>& m_NSWspType{m_tree.newVector<unsigned char>(m_NSWspKey.key()+"_type")};
    MuonVal::MatrixBranch<unsigned char>& m_spMatchedToPattern{m_tree.newMatrix<unsigned char>(m_spKey.key()+"_patternMatched")};
    MuonVal::MatrixBranch<unsigned char>& m_NSWspMatchedToPattern{m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_patternMatched")};
    MuonVal::MatrixBranch<unsigned char>& m_spMatchedToTruth{m_tree.newMatrix<unsigned char>(m_spKey.key()+"_truthMatched")};
    MuonVal::MatrixBranch<unsigned char>& m_NSWspMatchedToTruth{m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_truthMatched")};

    MuonVal::VectorBranch<short>& m_gen_Q{m_tree.newVector<short>("gen_Q", 0)};
    MuonVal::VectorBranch<float>& m_gen_Eta{m_tree.newVector<float>("gen_Eta",-10.)};
    MuonVal::VectorBranch<float>& m_gen_Phi{m_tree.newVector<float>("gen_Phi",-10.)};
    MuonVal::VectorBranch<float>& m_gen_Pt{m_tree.newVector<float>("gen_Pt",-10.)}; 

    MuonVal::MatrixBranch<unsigned char>& m_gen_nNonPrecMeas{m_tree.newMatrix<unsigned char>("gen_NNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_gen_nPrecMeas{m_tree.newMatrix<unsigned char>("gen_NPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_gen_nPhiMeas{m_tree.newMatrix<unsigned char>("gen_NPhiMeas", 0)};
 
    
    MuonVal::ScalarBranch<unsigned>& m_pat_n{m_tree.newScalar<unsigned>("pat_nPatterns", 0)};
    MuonVal::VectorBranch<float>& m_pat_Eta{m_tree.newVector<float>("pat_Eta", 0.0)};
    MuonVal::VectorBranch<float>& m_pat_phi{m_tree.newVector<float>("pat_Phi", 0.0)};
    MuonVal::VectorBranch<uint16_t>& m_pat_sector1{m_tree.newVector<uint16_t>("pat_Sector1", 0)};
    MuonVal::VectorBranch<uint16_t>& m_pat_sector2{m_tree.newVector<uint16_t>("pat_Sector2", 0)};
    MuonVal::VectorBranch<float>& m_pat_meanNormResidual2{m_tree.newVector<float>("pat_meanNormResidual2", 0.0)};
    MuonVal::VectorBranch<short>& m_pat_side{m_tree.newVector<short>("pat_Side", 0)};
    MuonVal::VectorBranch<unsigned char>& m_pat_nStations{m_tree.newVector<unsigned char>("pat_NStations", 0)};    

    MuonVal::MatrixBranch<unsigned char>& m_pat_nNonPrecMeas{m_tree.newMatrix<unsigned char>("pat_NNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nPrecMeas{m_tree.newMatrix<unsigned char>("pat_NPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nPhiMeas{m_tree.newMatrix<unsigned char>("pat_NPhiMeas", 0)};
    
    MuonVal::MatrixBranch<unsigned char>& m_pat_nTruthNonPrecMeas{m_tree.newMatrix<unsigned char>("pat_NTruthNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nTruthPrecMeas{m_tree.newMatrix<unsigned char>("pat_NTruthPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nTruthPhiMeas{m_tree.newMatrix<unsigned char>("pat_NTruthPhiMeas", 0)};

    MuonVal::MatrixBranch<unsigned char>& m_pat_nMisTruthNonPrecMeas{m_tree.newMatrix<unsigned char>("pat_NMisTruthNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nMisTruthPrecMeas{m_tree.newMatrix<unsigned char>("pat_NMisTruthPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nMisTruthPhiMeas{m_tree.newMatrix<unsigned char>("pat_NMisTruthPhiMeas", 0)};

    MuonVal::MatrixBranch<unsigned char>& m_pat_nPileupNonPrecMeas{m_tree.newMatrix<unsigned char>("pat_NPileupNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nPileupPrecMeas{m_tree.newMatrix<unsigned char>("pat_NPileupPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nPileupPhiMeas{m_tree.newMatrix<unsigned char>("pat_NPileupPhiMeas", 0)};

    MuonVal::MatrixBranch<unsigned char>& m_pat_nAllNonPrecMeas{m_tree.newMatrix<unsigned char>("pat_NAllNonPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nAllPrecMeas{m_tree.newMatrix<unsigned char>("pat_NAllPrecMeas", 0)};
    MuonVal::MatrixBranch<unsigned char>& m_pat_nAllPhiMeas{m_tree.newMatrix<unsigned char>("pat_NAllPhiMeas", 0)};

    MuonVal::MatrixBranch<unsigned char>& m_pat_MatchedToTruth{m_tree.newMatrix<unsigned char>("pat_truthMatched")};

    MuonVal::VectorBranch<float>& m_roi_EtaMin{m_tree.newVector<float>("roi_EtaMin",-10.)};
    MuonVal::VectorBranch<float>& m_roi_EtaMax{m_tree.newVector<float>("roi_EtaMax",-10.)};
    MuonVal::VectorBranch<float>& m_roi_PhiMin{m_tree.newVector<float>("roi_PhiMin",-10.)};
    MuonVal::VectorBranch<float>& m_roi_PhiMax{m_tree.newVector<float>("roi_PhiMax",-10.)};
    MuonVal::VectorBranch<float>& m_roi_ZMin{m_tree.newVector<float>("roi_ZMin",-10.)}; 
    MuonVal::VectorBranch<float>& m_roi_ZMax{m_tree.newVector<float>("roi_ZMax",-10.)};
    
    MuonVal::VectorBranch<float>& m_muon_Eta{m_tree.newVector<float>("muon_Eta", -10.)};
    MuonVal::VectorBranch<float>& m_muon_Phi{m_tree.newVector<float>("muon_Phi", -10.)};
    MuonVal::VectorBranch<float>& m_muon_Pt{m_tree.newVector<float>("muon_Pt", -10.)};
    MuonVal::VectorBranch<short>& m_muon_Q{m_tree.newVector<short>("muon_Q", 0)};
    MuonVal::VectorBranch<unsigned char>& m_muon_MatchedToPattern{m_tree.newVector<unsigned char>("muon_patMatched")};
 
    MuonR4::SpacePointPerLayerSorter m_spSorter{};
 
  };
}
 
#endif // MUONFASTDIGITEST_MUONVALR4_MuonHoughTransformTester_H