PatternVisualizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNRECOGNITIONTEST_PATTERNVISUALIZATIONTOOL_H
#define MUONR4_MUONPATTERNRECOGNITIONTEST_PATTERNVISUALIZATIONTOOL_H
 
#include <MuonRecToolInterfacesR4/IPatternVisualizationTool.h>
#include <MuonRecToolInterfacesR4/IRootVisualizationService.h>
 
#include <AthenaBaseComps/AthAlgTool.h>
 
#include <StoreGate/ReadDecorHandleKeyArray.h>
#include <StoreGate/ReadHandleKeyArray.h>
 
#include <xAODMeasurementBase/UncalibratedMeasurementContainer.h>
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <ActsGeometryInterfaces/GeometryContext.h>
#include <xAODMuon/MuonSegmentContainer.h>
 
#include <MuonPatternEvent/HoughEventData.h>
 
 
namespace MuonR4 {
    class SpacePoint;
}
 
namespace MuonValR4 {
    class PatternVisualizationTool : public extends<AthAlgTool, IPatternVisualizationTool> {
        public:
            
            using base_class::base_class;
 
            virtual StatusCode initialize() 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 LabeledSegmentSet = std::unordered_set<const xAOD::MuonSegment*>;
 
            virtual LabeledSegmentSet getLabeledSegments(const std::vector<const MuonR4::SpacePoint*>& hits) const override final;
            virtual LabeledSegmentSet getLabeledSegments(const std::vector<const xAOD::UncalibratedMeasurement*>& hits) const override final;
            
            virtual bool isLabeled(const MuonR4::SpacePoint& hit) const override final;
            virtual bool isLabeled(const xAOD::UncalibratedMeasurement& hit) const override final;
        private:
            using Canvas_t = IRootVisualizationService::ICanvasObject;
            using Edges = Canvas_t::AxisRanges;
            template<class SpacePointType>
                bool drawHits(const MuonR4::SpacePointBucket& bucket,
                              const std::vector<SpacePointType>& hitsToDraw,
                              Canvas_t& canvasDim,
                              unsigned int view) const;
 
            template<class SpacePointType>
                const MuonR4::SpacePoint* drawHit(const SpacePointType& hit,
                                                  Canvas_t& canvas,
                                                  const unsigned int view, 
                                                  unsigned int fillStyle) const;
            template<class SpacePointType>
                void writeChi2(const MuonR4::SegmentFit::Parameters& pars,
                              const std::vector<SpacePointType>& hits,
                              Canvas_t& canvas,
                              const double legX = 0.2, double startLegY = 0.8, 
                              const double endLegY  = 0.3) const;
            
            void paintSimHits(const EventContext& ctx,
                              const xAOD::MuonSegment& truthSeg,
                              Canvas_t& canvas,
                              const int view) const;
            ServiceHandle<IRootVisualizationService> m_visualSvc{this, "VisualSvc", "MuonValR4::RootVisualizationService"};
            IRootVisualizationService::ClientToken m_clientToken{};
            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_canvasPrefix{this, "CanvasPreFix", ""};
            Gaudi::Property<std::string> m_subDir{this, "outSubDir", ""};
            Gaudi::Property<bool> m_displayBucket{this, "displayBucket", true};
            Gaudi::Property<bool> m_accumlIsEta{this, "AccumulatorsInEtaPlane", true}; 
            Gaudi::Property<bool> m_doEtaBucketViews{this,"doEtaBucketViews", true};
            Gaudi::Property<bool> m_doPhiBucketViews{this,"doPhiBucketViews", false};
            Gaudi::Property<bool> m_paintTruthHits{this, "paintTruthHits", false};
            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<bool> m_displayOnlyTruth{this, "displayTruthOnly", false}; 
 
            const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
            SG::ReadHandleKey<ActsTrk::GeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
            mutable std::atomic<bool> m_plotsDone{false};
 
    };
    
}
 
#endif