TrackVisualizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONTRACKFINDINGTEST_TRACKVISUALIZATIONTOOL_H
#define MUONTRACKFINDINGTEST_TRACKVISUALIZATIONTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "MuonRecToolInterfacesR4/ITrackVisualizationTool.h"
 
#include "Acts/Utilities/RangeXD.hpp"
 
#include "TCanvas.h"
#include "TFile.h"
#include "TLegend.h"
 
namespace MuonR4{
    class MsTrackSeeder;
}
 
namespace MuonValR4{
    class TrackVisualizationTool : public extends<AthAlgTool, ITrackVisualizationTool> {
        public:
            using base_class::base_class;
            virtual ~TrackVisualizationTool() = default;
            
            virtual StatusCode initialize() override final;
            virtual StatusCode finalize() override final;
 
            virtual void displaySeeds(const EventContext& ctx,
                                      const MuonR4::MsTrackSeeder& seederObj,
                                      const xAOD::MuonSegmentContainer& segments,
                                      const MuonR4::MsTrackSeedContainer& seeds,
                                      const std::string& extraLabel) const override final;
            virtual void displaySeeds(const EventContext& ctx,
                                      const MuonR4::MsTrackSeeder& seederObj,
                                      const xAOD::MuonSegmentContainer& segments,
                                      const MuonR4::MsTrackSeedContainer& seeds,
                                      const std::string& extraLabel,
                                      PrimitivesVec_t && extPrimitives) const override final;
        private:
            struct PlotLegend {
                PlotLegend(const double xLow, const double yLow,
                           const double xHigh, const double yHigh):
                    legend{std::make_unique<TLegend>(xLow, yLow, xHigh, yHigh)}{}
                void addColor(const int color, const std::string& label);
                void addMarker(const int marker, const std::string& label);
                std::unique_ptr<TLegend> legend{};
                using LegendEntry_t = std::unordered_map<int, PrimitivePtr_t>;
                LegendEntry_t markers{};
                LegendEntry_t colors{};
            };
 
            using Location = MuonR4::MsTrackSeed::Location;
            using BoundBox_t = Acts::RangeXD<2, double>;
            static BoundBox_t emptyBounds();
            using AxisLabels_t = std::tuple<std::string, std::string>;
            std::unique_ptr<TCanvas> makeCanvas(const EventContext& ctx,
                                                const BoundBox_t& bounds,
                                                const AxisLabels_t& axisLabels) const;
            void closeSummaryCanvas() const;
            enum class DisplayView{RZ, XY};
            void displaySeeds(const EventContext& ctx,
                              const MuonR4::MsTrackSeeder& seederObj,
                              const DisplayView view,
                              const xAOD::MuonSegmentContainer& segments,
                              const MuonR4::MsTrackSeedContainer& seeds,
                              const std::string& extraLabel,
                              PrimitivesVec_t& extPrimitives) const;
 
 
            void fillTruthSeedPoints(const EventContext& ctx,
                                     const MuonR4::MsTrackSeeder& seeder,
                                     const DisplayView view,
                                     PlotLegend& legend, 
                                     PrimitivesVec_t& drawPrim) const;
            static Amg::Vector2D viewVector(const double phi,
                                            const Amg::Vector2D& posOnCylinder,
                                            const DisplayView view);
            SG::ReadHandleKey<xAOD::MuonSegmentContainer> m_truthSegKey{this, "TruthSegkey", "TruthSegmentsR4"};
            Gaudi::Property<unsigned> m_canvasLimit{this, "CanvasLimit", 5000};
            Gaudi::Property<bool> m_saveSinglePDFs{this, "saveSinglePDFs", true};
            Gaudi::Property<bool> m_saveSummaryPDF{this, "saveSummaryPDF",  false};
            Gaudi::Property<std::string> m_allCanName{this, "AllCanvasName", "AllMsTrackPlots"};
            Gaudi::Property<std::string> m_canvasPrefix{this, "CanvasPreFix", "MsTrackValid"};
            Gaudi::Property<unsigned> m_canvasWidth{this, "CanvasWidth", 800};
            Gaudi::Property<unsigned> m_canvasHeight{this, "CanvasHeight", 600};
            Gaudi::Property<std::string> m_AtlasLabel{this, "AtlasLabel", "Internal"};
            Gaudi::Property<std::string> m_sqrtSLabel{this, "SqrtSLabel", "14"};
            Gaudi::Property<std::string> m_lumiLabel{this, "LumiLabel", ""};
            static std::mutex s_mutex;
            mutable std::unique_ptr<TCanvas> m_summaryCan ATLAS_THREAD_SAFE{};
            mutable std::unique_ptr<TFile> m_outFile ATLAS_THREAD_SAFE{};
            mutable std::atomic<unsigned int> m_canvCounter ATLAS_THREAD_SAFE{0};
 
    };
}
 
#endif