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 <MuonPatternEvent/Segment.h>
#include <ActsGeometryInterfaces/GeometryContext.h>
#include <xAODMuon/MuonSegmentContainer.h>
 
#include <MuonPatternEvent/HoughEventData.h>
 
 
#include "TLegend.h"
#include "TLegendEntry.h"
 
#include <bitset>
 
 
namespace MuonR4 {
    class SpacePoint;
}
 
namespace MuonValR4 {
 
 
enum class LegendItem : std::size_t {
    RecoSegmentLine = 0,
    TruthSegmentLine,
    AuxiliaryConstraint,
 
    // general hits in the bucket (hollow filling)
    MdtHit,
    RpcHit,
    TgcHit,
    MmHit,
    StgcStripWireHit,
    StgcPadHit,
    OutlierHit,
 
    // hits on the objects (seeds, segments, etc) (full filling)
    MdtHitOnObject,
    RpcHitOnObject,
    TgcHitOnObject,
    MmHitOnObject,
    StgcStripWireHitOnObject,
    StgcPadHitOnObject,
 
    //True matched hits
    LabeledBox,
    LabeledTube,
 
    SelectedHit,
    AvailableHit,
 
    NumItems
};
using LegendMask = std::bitset<static_cast<std::size_t>(LegendItem::NumItems)>;
 
class DynamicLegend {
public:
    DynamicLegend()
        : m_legend{
              std::make_unique<TLegend>(
                  0.68, 0.56, 0.94, 0.90)} {
 
        m_legend->SetBorderSize(0);
        m_legend->SetFillStyle(0);
        m_legend->SetTextFont(43);
        m_legend->SetTextSize(10);
    }
 
    DynamicLegend( double xmin, double ymin, double xmax, double ymax,
                   int textfont = 43, double textSize = 10)
        : m_legend{
              std::make_unique<TLegend>(
                  xmin, ymin, xmax, ymax)} {
 
        m_legend->SetBorderSize(0);
        m_legend->SetFillStyle(0);
        m_legend->SetTextFont(textfont);
        m_legend->SetTextSize(textSize);
    }
 
    TLegendEntry* addOnce(
        const LegendItem item,
        TObject* object,
        const char* label,
        const char* option) {
 
        const std::size_t index =
            static_cast<std::size_t>(item);
 
        if (m_entries.test(index)) {
            return nullptr;
        }
 
        TLegendEntry* entry =
            m_legend->AddEntry(
                object, label, option);
 
        if (entry) {
            m_entries.set(index);
        }
 
        return entry;
    }
 
    bool empty() const {
        return m_legend->GetNRows() == 0;
    }
 
    std::unique_ptr<TLegend> release() {
        return std::move(m_legend);
    }
 
private:
    LegendMask m_entries{};
    std::unique_ptr<TLegend> m_legend;
};
 
 
 
    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, DynamicLegend& legend,
                              unsigned int view) const;

            template<class SpacePointType>
                const MuonR4::SpacePoint* drawHit(const SpacePointType& hit,
                                                  Canvas_t& canvas, DynamicLegend& legend,
                                                  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}; 
            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{false};
 
    };
    
 
 
}
 
#endif