PatternVisualizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNRECOGNITIONTEST_PATTERNVISUALIZATIONTOOL_H
#define MUONR4_MUONPATTERNRECOGNITIONTEST_PATTERNVISUALIZATIONTOOL_H
 
#include <MuonRecToolInterfacesR4/IPatternVisualizationTool.h>
#include <AthenaBaseComps/AthAlgTool.h>
 
#include <StoreGate/ReadDecorHandleKeyArray.h>
#include <StoreGate/ReadHandleKeyArray.h>
 
#include <xAODMeasurementBase/UncalibratedMeasurementContainer.h>
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <ActsGeometryInterfaces/ActsGeometryContext.h>
#include <xAODMuon/MuonSegmentContainer.h>
 
#include <MuonPatternEvent/HoughEventData.h>
 
#include "TCanvas.h"
#include "TFile.h"
#include <mutex>
 
namespace MuonR4 {
    class SpacePoint;
}
 
namespace MuonValR4 {
    class PatternVisualizationTool : public extends<AthAlgTool, IPatternVisualizationTool> {
        public:
            
            PatternVisualizationTool(const std::string& type, const std::string& name, const IInterface* parent);
 
            virtual StatusCode initialize() override final;
            virtual StatusCode finalize() override final;
 
            virtual void visualizeBucket(const EventContext& ctx,
                                         const MuonR4::SpacePointBucket& bucket,
                                         const std::string& extraLabel) const override final;
            virtual void visualizeBucket(const EventContext& ctx,
                                         const MuonR4::SpacePointBucket& bucket,
                                         const std::string& extraLabel,
                                         PrimitiveVec&& extraPaints) const override final;
            
            virtual void visualizeSeed(const EventContext& ctx,
                                       const MuonR4::SegmentSeed& seed,
                                       const std::string& extraLabel) const override final;
            
            
            virtual void visualizeSeed(const EventContext& ctx,
                                       const MuonR4::SegmentSeed& seed,
                                       const std::string& extraLabel,
                                       PrimitiveVec&& extraPaints) const override final;
 
 
            virtual void visualizeAccumulator(const EventContext& ctx,
                                              const MuonR4::HoughPlane& accumulator,
                                              const Acts::HoughTransformUtils::HoughAxisRanges& axisRanges,
                                              const MaximumVec& maxima,
                                              const std::string& extraLabel) const override final;
            
            virtual void visualizeAccumulator(const EventContext& ctx,
                                              const MuonR4::HoughPlane& accumulator,
                                              const Acts::HoughTransformUtils::HoughAxisRanges& axisRanges,
                                              const MaximumVec& maxima,
                                              const std::string& extraLabel,
                                              PrimitiveVec&& extraPaints) const override final;
            
            virtual void visualizeSegment(const EventContext& ctx,
                                          const MuonR4::Segment& segment,
                                          const std::string& extraLabel) const override final;
            
            virtual void visualizeSegment(const EventContext& ctx,
                                          const MuonR4::Segment& segment,
                                          const std::string& extraLabel,
                                          PrimitiveVec&& extraPaints) const override final;
 
 
            using TruthSegmentSet = std::unordered_set<const xAOD::MuonSegment*>;
            virtual TruthSegmentSet fetchTruthSegs(const std::vector<const MuonR4::SpacePoint*>& hits) const override final;
            virtual TruthSegmentSet fetchTruthSegs(const std::vector<const xAOD::UncalibratedMeasurement*>& hits) const override final;
            
            virtual bool isTruthMatched(const MuonR4::SpacePoint& hit) const override final;
            virtual bool isTruthMatched(const xAOD::UncalibratedMeasurement& hit) const override final;
        private:
            void closeSummaryCanvas() const;
            std::unique_ptr<TCanvas> makeCanvas(const EventContext& ctx,
                                                const std::array<double, 4>& canvasDim,
                                                const int view) const;
 
            void saveCanvas(const EventContext& ctx,
                            const Identifier& chambId,
                            TCanvas& canvas,
                            const std::string& extraLabel) const;
            
            template<class SpacePointType>
                bool drawHits(const MuonR4::SpacePointBucket& bucket,
                              const std::vector<SpacePointType>& hitsToDraw,
                              PrimitiveVec& primitivesToPush,
                              std::array<double, 4>& canvasDim,
                              unsigned int view) const;
 
            template<class SpacePointType>
                const MuonR4::SpacePoint* drawHit(const SpacePointType& hit,
                                                  PrimitiveVec& primitives,
                                                  std::array<double, 4>& canvasDim,
                                                  const unsigned int view, 
                                                  unsigned int fillStyle) const;
            template<class SpacePointType>
                void writeChi2(const MuonR4::SegmentFit::Parameters& pars,
                              const std::vector<SpacePointType>& hits,
                              PrimitiveVec& primitivesToPush,
                              const double legX = 0.15, double startLegY = 0.8, 
                              const double endLegY  = 0.3) const;
            
            Gaudi::Property<unsigned int> m_canvasLimit{this, "CanvasLimits", 5000};
            Gaudi::Property<bool> m_saveSinglePDFs{this, "saveSinglePDFs", false};
            Gaudi::Property<bool> m_saveSummaryPDF{this, "saveSummaryPDF",  false};
            Gaudi::Property<std::string> m_allCanName{this, "AllCanvasName", "AllPatternPlots"};
            Gaudi::Property<std::string> m_canvasPrefix{this, "CanvasPreFix", ""};
            Gaudi::Property<bool> m_displayBucket{this, "displayBucket", true};
            Gaudi::Property<double> m_canvasExtraScale{this, "CanvasExtraScale" , 1.3};
            Gaudi::Property<bool> m_accumlIsEta{this, "AccumulatorsInEtaPlane", true}; 
            Gaudi::Property<bool> m_doEtaBucketViews{this,"doEtaBucketViews", true};
            Gaudi::Property<bool> m_doPhiBucketViews{this,"doPhiBucketViews", true};
            SG::ReadHandleKeyArray<xAOD::UncalibratedMeasurementContainer> m_prepContainerKeys{this, "PrdContainer", {}};
            Gaudi::Property<std::set<std::string>> m_truthSegLinks{this, "TruthSegDecors", {}};
            SG::ReadDecorHandleKeyArray<xAOD::UncalibratedMeasurementContainer> m_truthLinkDecorKeys{this, "LinkDecorKeys", {}};
            using SegLink_t = ElementLink<xAOD::MuonSegmentContainer>;
            using SegLinkVec_t = std::vector<SegLink_t>;
            using SegLinkDecor_t = SG::AuxElement::ConstAccessor<SegLinkVec_t>;
            std::vector<SegLinkDecor_t> m_truthLinkDecors{};
           
            Gaudi::Property<unsigned> m_canvasWidth{this, "CanvasWidth", 800};
            Gaudi::Property<unsigned> m_canvasHeight{this, "CanvasHeight", 600};
 
            Gaudi::Property<bool> m_displayOnlyTruth{this, "displayTruthOnly", false}; 
 
 
            const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
            SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
            static std::mutex s_mutex;
            mutable std::unique_ptr<TCanvas> m_allCan 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