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/ReadDecorHandleKeyArray.h"
 
 
#include "MuonRecToolInterfacesR4/ISegmentSelectionTool.h"
#include "MuonRecToolInterfacesR4/ITrackSummaryTool.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 "MuonTrackFindingTools/MsTrackSeeder.h"
#include "MuonPRDTestR4/TrackSummaryModule.h"
 
#include "MuonPatternEvent/MuonPatternContainer.h"
#include "MuonTrackEvent/MsTrackSeed.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::MsTrackSeeder::SectorProjector;
        std::optional<MuonR4::MsTrackSeed> makeSeedFromTruth(const ActsTrk::GeometryContext& gctx,
                                                             const xAOD::TruthParticle& truthMuon) const;
        std::pair<double, double>  calcSeedLength(const ActsTrk::GeometryContext& gctx, 
                                                  const MuonR4::MsTrackSeed& seed) const;

        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};
 
 
        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>;
        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::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
        SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheKey{this, "MagFieldKey", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
        ToolHandle<MuonR4::ISegmentSelectionTool> m_segSelector{this, "SegmentSelectionTool" , "" };
        MuonKey_t m_muonKey{this, "MuonKey", "MuonsR4"};
        ToolHandle<MuonR4::ITrackSummaryTool> m_summaryTool{this, "SummaryTool" ,""};
        TrackKey_t m_legacyTrackKey{this,"LegacyTrackKey", "MuonSpectrometerTrackParticles"};

        MuonKey_t m_legacyMuonKey{this,"LegacyMuonKey", "Muons"};
 
        std::unique_ptr<MuonR4::MsTrackSeeder> m_seeder{};
        
        using ParticleBranchPtr_t = std::shared_ptr<MuonVal::IParticleFourMomBranch>;
        ParticleBranchPtr_t m_truthTrks{};
        ParticleBranchPtr_t m_muonTrks{};
 
        using SegmentBranchPtr_t = std::shared_ptr<MuonPRDTest::SegmentVariables>;
        SegmentBranchPtr_t m_truthSegs{};
        SegmentBranchPtr_t m_recoSegs{};
        SegmentBranchPtr_t m_legacyRecoSegs{};

        MuonVal::ThreeVectorBranch m_seedPos{m_tree, "MsTrkSeed_position"};
        MuonVal::VectorBranch<char>& m_seedType{m_tree.newVector<char>("MsTrkSeed_type")};
        MuonVal::VectorBranch<int>& m_seedSector{m_tree.newVector<int>("MsTrkSeed_sector")};
        MuonVal::VectorBranch<float>& m_seedLength{m_tree.newVector<float>("MsTrkSeed_length")};
        MuonVal::VectorBranch<float>& m_seedThetaCone{m_tree.newVector<float>("MsTrkSeed_thetaCone")};
        MuonVal::VectorBranch<float>& m_seedQP{m_tree.newVector<float>("MsTrkSeed_qTimesP")};
        MuonVal::VectorBranch<unsigned short>& m_seedTruthLink{m_tree.newVector<unsigned short>("MsTrkSeed_truthLink", -1)};
        std::shared_ptr<TrackSummaryModule> m_seedSummary{};
        MuonVal::MatrixBranch<unsigned short>& m_seedRecoSegMatch{m_tree.newMatrix<unsigned short>("MsTrkSeed_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