MsTrackTester.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONTRACKFINDINGTEST_MSTRACKTESTER_H
#define MUONTRACKFINDINGTEST_MSTRACKTESTER_H
 
#include "AthenaBaseComps/AthHistogramAlgorithm.h"
#include "MuonTesterTree/MuonTesterTreeDict.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadDecorHandleKeyArray.h"
 
#include "MuonRecToolInterfacesR4/ITrackSummaryTool.h"
#include "MuonRecToolInterfacesR4/ISegmentSelectionTool.h"
#include "MuonRecToolInterfacesR4/ITrackSeedingDiagnosticsTool.h"
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
 
#include "ActsEvent/TrackContainer.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODMuonSimHit/MuonSimHitContainer.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODMuon/MuonSegmentContainer.h"
#include "xAODMuon/MuonContainer.h"
#include "MuonPRDTest/SegmentVariables.h"
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
#include "MuonPRDTestR4/TrackSummaryModule.h"
 
#include "MuonPatternEvent/MuonPatternContainer.h"
#include "MuonTrackEvent/MsTrackSeed.h"
#include "MuonTrackEvent/MuonTag.h"
 
#include "ActsEvent/ContextUtility.h"
#include "ActsGeometryInterfaces/IExtrapolationTool.h"
 
 
namespace MuonValR4{
  class MsTrackTester : public AthHistogramAlgorithm {
      public:
          using AthHistogramAlgorithm::AthHistogramAlgorithm;
 
          StatusCode initialize() override final;
          StatusCode execute(const EventContext& ctx) override final;
          StatusCode finalize() override final;
      private:
        using Location = MuonR4::MsTrackSeed::Location;
        using SectorProjector = MuonR4::ExpandedSector::SectorProjector;
        std::optional<MuonR4::MsTrackSeed> makeSeedFromTruth(const Acts::GeometryContext& tgContext,
                                                             const xAOD::TruthParticle& truthMuon) const;
        std::pair<double, double>  calcSeedLength(const Acts::GeometryContext& tgContext,
                                                  const MuonR4::MsTrackSeed& seed) const;
 
        
        const xAOD::TruthParticle* truthTreeParticle(const xAOD::IParticle& part) const;
        std::vector<const xAOD::MuonSegment*> getAssociatedSegments(const xAOD::TrackParticle& idTrack,
                                                                    const EventContext& ctx) const;

        const MuonR4::MuonTag* findBaseIdTag(const xAOD::TrackParticle& idTrack,
                                            const EventContext& ctx) const;
 
        const MuonR4::MuonTag* findMuTagIMO(const xAOD::TrackParticle& idTrack,
                                            const EventContext& ctx) const;
 
 
        const MuonGMR4::SpectrometerSector* getEnvelope(const xAOD::MuonSegment& segment) const;
 
                                            
        struct SegmentTagVariables{
            std::vector<std::uint8_t> recoSegs{};
            std::vector<float> matchScores{};
            std::vector<float> deltaTheta{};
            std::vector<float> deltaPhi{};
            std::vector<float> deltaY0{};
            std::vector<float> deltaX0{};
            std::vector<std::uint8_t> goodExtp{};
            std::vector<std::uint8_t> taggedSeg{};
 
        };
      
        SegmentTagVariables calcSegTagVariables(const xAOD::TrackParticle& idTrack,
                                              const EventContext& ctx); 

        StatusCode dumpLegacyTracks(const EventContext& ctx);
        StatusCode dumpTruthContent(const EventContext& ctx);
        StatusCode dumpRecoContent(const EventContext& ctx);

        MuonVal::MuonTesterTree m_tree{"MsTrackValidTest", "MuonTrackTester"};
        const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
        Gaudi::Property<bool> m_isMC{this, "isMC", false};
        Gaudi::Property<bool> m_storeID{this, "storeIdTrks", true};
 
        using TruthHitCol = std::unordered_set<const xAOD::MuonSimHit*>;
        using SegmentKey_t = SG::ReadHandleKey<xAOD::MuonSegmentContainer>;
        using TrackKey_t = SG::ReadHandleKey<xAOD::TrackParticleContainer>;
        using MuonKey_t = SG::ReadHandleKey<xAOD::MuonContainer>;
        using MuonTagKey_t = SG::ReadHandleKey<MuonR4::MuonTagContainer>;
        SegmentKey_t m_truthSegmentKey{this, "TruthSegmentKey", "MuonTruthSegments"};
        SegmentKey_t m_recoSegmentKey{this, "SegmentKey", "MuonSegmentsFromR4"};
        SegmentKey_t m_legacySegmentKey{this, "LegacySegmentKey", "MuonSegments"};
        SG::ReadHandleKey<xAOD::TruthParticleContainer> m_truthKey{this, "TruthKey", "MuonTruthParticles"};
        SG::ReadDecorHandleKeyArray<SG::AuxVectorBase> m_trkTruthLinks{this, "TruthTrackLinks", {}};
        SG::ReadHandleKey<MuonR4::MsTrackSeedContainer> m_msTrkSeedKey{this, "MsTrkSeedKey", "MsTrackSeeds"};

        ActsTrk::ContextUtility m_ctxProvider{this};
        MuonKey_t m_muonKey{this, "MuonKey", "MuonsR4"};
        ToolHandle<MuonR4::ITrackSummaryTool> m_summaryTool{this, "SummaryTool" ,""};
        ToolHandle<MuonR4::ITrackSeedingDiagnosticsTool> m_seedingTool{this, "SeedingTool", ""};
        ToolHandle<MuonR4::ISegmentSelectionTool> m_segSelector{this, "SegmentSelectionTool" , "" };
        ToolHandle<ActsTrk::IExtrapolationTool> m_extrapolationTool{this, "ExtrapolationTool" ,"" };
        TrackKey_t m_legacyTrackKey{this,"LegacyTrackKey", "MuonSpectrometerTrackParticles"};
        TrackKey_t m_idTrackKey{this, "IdTrackKey", "InDetTrackParticles"};
        MuonTagKey_t m_idTagKey{this, "IdTagKey", "MuonInDetCandidates"};
        MuonTagKey_t m_segTagKey{this, "SegTagKey", "SegmentTags"};

        Gaudi::Property<double> m_toleranceX0{this, "toleranceX0", 20.*Gaudi::Units::cm};
        Gaudi::Property<double> m_toleranceY0{this, "toleranceY0", 5.*Gaudi::Units::cm};
        Gaudi::Property<double> m_toleranceTheta{this, "toleranceTheta", 1.*Gaudi::Units::deg};
        Gaudi::Property<double> m_tolerancePhi{this, "tolerancePhi", 2.*Gaudi::Units::deg};

        MuonKey_t m_legacyMuonKey{this,"LegacyMuonKey", "Muons"};

        std::unique_ptr<const Acts::Logger> m_logger{};
        const Acts::Logger& logger() const { return *m_logger; }
 
        
        using ParticleBranchPtr_t = std::shared_ptr<MuonVal::IParticleFourMomBranch>;
        ParticleBranchPtr_t m_truthTrks{};
        ParticleBranchPtr_t m_muonTrks{};
        ParticleBranchPtr_t m_idTracks{};

        using SegmentBranchPtr_t = std::shared_ptr<MuonPRDTest::SegmentVariables>;
        SegmentBranchPtr_t m_truthSegs{};
        SegmentBranchPtr_t m_recoSegs{};
        SegmentBranchPtr_t m_legacyRecoSegs{};
        MuonVal::ScalarBranch<std::uint16_t>& m_nIdTracks{m_tree.newScalar<std::uint16_t>("nIdTracks", 0)};
        MuonVal::ScalarBranch<std::uint16_t>& m_nIdTags{m_tree.newScalar<std::uint16_t>("nIdTags", 0)};
        MuonVal::ThreeVectorBranch m_seedPos{m_tree, "TrkSeed_position"};
        MuonVal::UnitThreeVectorBranch m_seedDir{m_tree, "TrkSeed_direction"};
        MuonVal::VectorBranch<char>& m_seedType{m_tree.newVector<char>("TrkSeed_type")};
        MuonVal::VectorBranch<int>& m_seedSector{m_tree.newVector<int>("TrkSeed_sector")};
        MuonVal::VectorBranch<float>& m_seedLength{m_tree.newVector<float>("TrkSeed_length")};
        MuonVal::VectorBranch<float>& m_seedThetaCone{m_tree.newVector<float>("TrkSeed_thetaCone")};
        MuonVal::VectorBranch<char>& m_seedGood{m_tree.newVector<char>("TrkSeed_goodSeed")};
        MuonVal::VectorBranch<float>& m_seedQP{m_tree.newVector<float>("TrkSeed_qTimesP")};
        MuonVal::VectorBranch<unsigned short>& m_seedTruthLink{m_tree.newVector<unsigned short>("TrkSeed_truthLink", -1)};
        std::shared_ptr<TrackSummaryModule> m_seedSummary{};
        MuonVal::MatrixBranch<unsigned short>& m_seedRecoSegMatch{m_tree.newMatrix<unsigned short>("TrkSeed_segmentLinks")};
        MuonVal::MatrixBranch<unsigned short>& m_truthSegToRecoLink{m_tree.newMatrix<unsigned short>("TruthSegments_recoSegLinks",-1)};

        MuonVal::VectorBranch<unsigned short>& m_legacySegToTrkLinks{m_tree.newVector<unsigned short>("LegacyRecoSegments_trkLinks", -1)};

        MuonVal::MatrixBranch<unsigned short>& m_truthMuToSeedIdx{m_tree.newMatrix<unsigned short>("TruthMuons_seedLinks", -1)};
        MuonVal::MatrixBranch<unsigned short>& m_truthMuToSeedCounter{m_tree.newMatrix<unsigned short>("TruthMuons_seedNSeg")};
        MuonVal::MatrixBranch<unsigned short>& m_truthMuRecoSegLinks{m_tree.newMatrix<unsigned short>("TruthMuons_recoSegLinks")};
 
        ParticleBranchPtr_t m_legacyTrks{};
    };
}
 
 
#endif