FastRecoVisualizationTool.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/IFastRecoVisualizationTool.h>
#include <MuonRecToolInterfacesR4/IRootVisualizationService.h>
#include "MuonVisualizationHelpersR4/VisualizationHelpers.h"
#include <MuonFastRecoEvent/GlobalPattern.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 <MuonPatternEvent/Segment.h>
#include <xAODMuon/MuonSegmentContainer.h>
 
 
namespace MuonR4 {
    class SpacePoint;
}
 
namespace MuonValR4 {
    class FastRecoVisualizationTool : public extends<AthAlgTool, IFastRecoVisualizationTool> {
        public:
            using base_class::base_class;
 
            virtual StatusCode initialize() override final;
 
            virtual void plotPatternBuckets(const EventContext& ctx,
                                            const std::string& extraLabel,
                                            PatternHitVisualInfoVec&& patternVisualVec) const override final;
            virtual void plotPatternBuckets(const EventContext& ctx,
                                            const std::string& extraLabel,
                                            PatternHitVisualInfoVec&& patternVisualVec,
                                            PrimitiveVec&& extraPaints) const override final;
            virtual void plotPatternBuckets(const EventContext& ctx,
                                            const std::string& extraLabel,
                                            PatternHitVisualInfo&& patternVisual) const override final;
            virtual void plotPatternBuckets(const EventContext& ctx,
                                            const std::string& extraLabel,
                                            PatternHitVisualInfo&& patternVisual,
                                            PrimitiveVec&& extraPaints) const override final;

            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:
            enum class View {
                objViewEta = static_cast<int>(MuonValR4::objViewEta),
                objViewPhi = static_cast<int>(MuonValR4::objViewPhi),
                objViewZR = 2,
                objViewRZ = 3
            };
            using Canvas_t = IRootVisualizationService::ICanvasObject;
            using Edges = Canvas_t::AxisRanges;
            void plotPatternBucket(const EventContext& ctx,
                                   const std::string& extraLabel,
                                   const MuonR4::SpacePointBucket& bucket,
                                   PatternHitVisualInfo&& patternVisual,
                                   PrimitiveVec&& extraPaints) const;
            void drawSearchWindow(const Acts::Transform3& localToGlobalBucket,
                                  PrimitiveVec& outputContainer,
                                  const double thetaMin, 
                                  const double thetaMax,
                                  const Canvas_t& canvas,
                                  const View view) const;
            void drawLineResidual(const ActsTrk::GeometryContext& gctx,
                                  const Acts::Transform3& localToGlobalBucket,
                                  PrimitiveVec& outputContainer,
                                  const MuonR4::SpacePoint* seed, 
                                  const MuonR4::SpacePoint* testHit,
                                  const double lineSlope,
                                  const double Rwindow,
                                  const PatternHitVisualInfo::HitStatus status,
                                  const Canvas_t& canvas,
                                  const View view) const;
            void drawSegment(const xAOD::MuonSegment& segment,
                             const Acts::Transform3& localToGlobalBucket,
                             PrimitiveVec& outputContainer,
                             bool& drawnTrueLabel,
                             const Canvas_t& canvas,
                             const View view) const;
            template<class SpacePointType>
                bool drawHits(const MuonR4::SpacePointBucket& bucket,
                              const Acts::Transform3& localToGlobalBucket,
                              const std::vector<SpacePointType>& hitsToDraw,
                              Canvas_t& canvasDim,
                              const View view) const;

            template<class SpacePointType>
                const MuonR4::SpacePoint* drawHit(const SpacePointType& hit,
                                                  const Acts::Transform3& localToGlobalBucket,
                                                  Canvas_t& canvas,
                                                  const View view, 
                                                  unsigned int fillStyle) const;

            void paintSimHits(const ActsTrk::GeometryContext& gctx,
                              const Acts::Transform3& localToGlobalBucket,
                              const xAOD::MuonSegment& truthSeg,
                              PrimitiveVec& outputContainer,
                              const View view) const;
            std::unique_ptr<TLine> drawLine(const Amg::Vector3D& lineDirection,
                                            const Amg::Vector3D& linePoint,
                                            const double lowEnd, 
                                            const double highEnd,
                                            const int color = kRed +1,
                                            const int lineStyle = kDashed,
                                            const View view = View::objViewEta) const;

            ServiceHandle<IRootVisualizationService> m_visualSvc{this, "VisualSvc", "MuonValR4::RootVisualizationService"};
            IRootVisualizationService::ClientToken m_clientToken{};
            UnsignedIntegerProperty m_canvasLimit{this, "CanvasLimits", 5000}; 
            BooleanProperty m_saveSinglePDFs{this, "saveSinglePDFs", false};
            BooleanProperty m_saveSummaryPDF{this, "saveSummaryPDF",  false};
            StringProperty m_canvasPrefix{this, "CanvasPreFix", ""};
            StringProperty m_subDir{this, "outSubDir", ""};
            BooleanProperty m_doEtaBucketViews{this,"doEtaBucketViews", true};
            BooleanProperty m_doPhiBucketViews{this,"doPhiBucketViews", false};
            BooleanProperty m_doRZBucketViews{this,"doRZBucketViews", false};
            BooleanProperty m_paintTruthHits{this, "paintTruthHits", false};
            BooleanProperty m_paintTruthSegment{this, "paintTruthSegment", false};
            BooleanProperty m_paintSuccessfullPatterns {this, "PaintSuccessfullPatterns", true, "Toggle the display of successfully built patterns in the visualization"};
            BooleanProperty m_paintFailedPatterns {this, "PaintFailedPatterns", false, "Toggle the display of failed patterns in the visualization"};
            BooleanProperty m_paintOverlapPatterns {this, "PaintOverlapPatterns", false, "Toggle the display of overlap patterns in the visualization"};
            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::ConstAccessor<SegLinkVec_t>;
            std::vector<SegLinkDecor_t> m_truthLinkDecors{};

            BooleanProperty m_displayOnlyTruth{this, "displayTruthOnly", false}; 
            BooleanProperty m_displayOnlyWithPattern{this, "displayOnlyWithPattern", true}; 

            const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr}; 
            ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
            mutable std::atomic<bool> m_plotsDone ATLAS_THREAD_SAFE {false};
    };
    
}
 
#endif