MuonValR4::TrackVisualizationTool Class Reference

#include <TrackVisualizationTool.h>

Inheritance diagram for MuonValR4::TrackVisualizationTool:

Collaboration diagram for MuonValR4::TrackVisualizationTool:

Classes
struct	PlotLegend
	Helper struct to administer the markers & colors that are added to the legend. More...

Public Member Functions
virtual	~TrackVisualizationTool ()=default
	Destructor.
virtual StatusCode	initialize () override final
virtual void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds) const override final
	Displays all segments on the representative cylinder in the R-Z & X-Y plane and draws the markers of the successfully built seeds & truth segments.
virtual void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds, PrimitivesVec_t &&extPrimitives) const override final
	Displays all segments on the representative cylinder in the R-Z & X-Y plane and draws the markers of the successfully built seeds & truth segments.
virtual void	displayTrackSeedObj (const EventContext &ctx, const MuonR4::MsTrackSeed &seed, const OptBoundPars_t &parsToExt, const std::string &objName="") const override final
	Visualizes the measurements of the segments on the track seed together with their predicted local line parameters as an obj file.

Private Types
enum class	DisplayView { RZ , XY }
	Enumeration to toggle whether the seeds shall be painted in x-y or R-z view. More...
using	Canvas_t = IRootVisualizationService::ICanvasObject
using	Edges = Canvas_t::AxisRanges
using	Location = MuonR4::MsTrackSeed::Location
	Enumeration to toggle whether the segment shall displayed on the barrel/endcap.

Private Member Functions
void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const DisplayView view, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds, PrimitivesVec_t &&extPrimitives) const
	Actual implementation of the display seeds method with the augmentation to define the view.
void	fillTruthSeedPoints (const EventContext &ctx, const MuonR4::MsTrackSeeder &seeder, const DisplayView view, PlotLegend &legend, Canvas_t &canvas) const
	Add the truth segments to the canvas.

Static Private Member Functions
static Amg::Vector2D	viewVector (const double phi, const Amg::Vector2D &posOnCylinder, const DisplayView view)
	Transforms the projected vector into the actual view, if it's xy then an external phi is needed to place the marker.

Private Attributes
ToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool" ,"" }
	Track extrapolation tool.
ServiceHandle< IRootVisualizationService >	m_visualSvc {this, "VisualSvc", "MuonValR4::RootVisualizationService"}
	Service handle of the visualization service.
IRootVisualizationService::ClientToken	m_clientToken {}
	Token to present to the visualization service such that the display froms this tool are grouped together.
SG::ReadHandleKey< xAOD::MuonSegmentContainer >	m_truthSegKey {this, "TruthSegkey", "MuonTruthSegments"}
	Key to the truth segment selection to draw the segment parameters.
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Dependency on the geometry alignment.
Gaudi::Property< unsigned >	m_canvasLimit {this, "CanvasLimit", 5000}
	Maximum canvases to draw.
Gaudi::Property< bool >	m_saveSinglePDFs {this, "saveSinglePDFs", true}
	If set to true each canvas is saved into a dedicated pdf file.
Gaudi::Property< bool >	m_saveSummaryPDF {this, "saveSummaryPDF", true}
	If set to true a summary Canvas is created.
Gaudi::Property< std::string >	m_subDir {this, "outSubDir", ""}
	Define the subdirectory in which the plots shall be saved.
Gaudi::Property< std::string >	m_canvasPrefix {this, "CanvasPreFix", "MsTrackValid"}
	Prefix of the individual canvas file names <MANDATORY>
std::atomic< bool >	m_plotsDone {false}
	Flag toggling whether all Canvases have been exhausted.
std::atomic< unsigned >	m_objCounter {0}
	How many obj have been produced.

Detailed Description

Definition at line 19 of file TrackVisualizationTool.h.

Member Typedef Documentation

Canvas_t

using MuonValR4::TrackVisualizationTool::Canvas_t = IRootVisualizationService::ICanvasObject

private

Definition at line 64 of file TrackVisualizationTool.h.

Edges

using MuonValR4::TrackVisualizationTool::Edges = Canvas_t::AxisRanges

private

Definition at line 65 of file TrackVisualizationTool.h.

Location

using MuonValR4::TrackVisualizationTool::Location = MuonR4::MsTrackSeed::Location

private

Enumeration to toggle whether the segment shall displayed on the barrel/endcap.

Definition at line 93 of file TrackVisualizationTool.h.

Member Enumeration Documentation

DisplayView

enum class MuonValR4::TrackVisualizationTool::DisplayView

strongprivate

Enumeration to toggle whether the seeds shall be painted in x-y or R-z view.

Enumerator
RZ
XY

Definition at line 95 of file TrackVisualizationTool.h.

{RZ, XY};

Constructor & Destructor Documentation

~TrackVisualizationTool()

virtual MuonValR4::TrackVisualizationTool::~TrackVisualizationTool ( )

virtualdefault

Destructor.

Member Function Documentation

displaySeeds() [1/3]

void MuonValR4::TrackVisualizationTool::displaySeeds ( const EventContext & ctx, const MuonR4::MsTrackSeeder & seederObj, const DisplayView view, const xAOD::MuonSegmentContainer & segments, const MuonR4::MsTrackSeedContainer & seeds, PrimitivesVec_t && extPrimitives ) const

private

Actual implementation of the display seeds method with the augmentation to define the view.

Parameters

ctx	EventContext to access store gate & conditions
seederObj	Configured instance of the track seeder which actually constructed the seeds.
view	Actual view to display
segments	Container of all MS segments in the event
seeds	The constructed track seeds from the event
extPrimitives	Extra TObjects that should be additionally painted onto the Canvases

First add the truth points

Draw the sector map

Definition at line 141 of file TrackVisualizationTool.cxx.

                                                                                    {
 
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, std::format("SeedDisplay{:}",
                                                                                 view == DisplayView::XY ? "XY" : "RZ" ));  
        
        if (!canvas) {
            m_plotsDone = true;
            return;
        }     
        canvas->setAxisTitles(view == DisplayView::XY ?  "x [m]" : "z [m]",
                              view == DisplayView::XY ?  "y [m]" : "R [m]");
        
        PlotLegend legend{0.005,0.005, 0.6,0.1};
        fillTruthSeedPoints(ctx, seeder, view, legend, *canvas);
              
        auto onSeed = [&seeds](const xAOD::MuonSegment* segment,
                               const Location loc) {
            return std::ranges::any_of(seeds,[segment, loc](const MsTrackSeed& seed){
                return seed.location() == loc && std::ranges::find(seed.segments(), segment) != seed.segments().end();
            });
        };
           
        const ActsTrk::GeometryContext* gctx{nullptr};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Failed to fetch the geometry context "<<m_geoCtxKey.fullKey());
        }
        bool drawnPoint{false};
 
        for (const xAOD::MuonSegment* segment: segments) {
            using enum Location;
            using enum MsTrackSeeder::SectorProjector;
            using namespace Muon;
            const MuonGMR4::SpectrometerSector* msSector = detailedSegment(*segment)->msSector();
            const auto chIdx = segment->chamberIndex();
            const int mColor = msSector->barrel() ? ColorBarrel : (msSector->side() > 0 ? ColorEndcapA : ColorEndcapC);
 
            for (const auto secProj : {leftOverlap, center, rightOverlap}) {
                if (!sectorMap.insideSector(segment->sector() + Acts::toUnderlying(secProj),
                                            segment->position().phi())){
                    continue;
                }
 
                for (const Location loc : {Barrel, Endcap}) {
                    const Amg::Vector2D projPos{seeder.expressOnCylinder(*gctx, *segment, loc, secProj)};
                    if (!seeder.withinBounds(projPos, loc)) {
                        continue;
                    }
                    drawnPoint = true;
                    const bool isGood = onSeed(segment, loc);
                    const int mStyle = stationMarkerSyle(chIdx, false, isGood);
                    const double phi = seeder.projectedPhi(segment->sector(), secProj);
                    const Amg::Vector2D markerPos{viewVector(phi, projPos, view)};
                    extPrimitives.emplace_back(drawMarker(markerPos, mStyle, mColor));
 
                    if (view == DisplayView::XY) {
                        const double r = markerPos.mag() + extraMargin;
                        canvas->expandPad(r, r);
                        canvas->expandPad(-r, -r);
                    } else {
                        canvas->expandPad(markerPos[0] - extraMargin, markerPos[1] - extraMargin);
                        canvas->expandPad(markerPos[0] + extraMargin, markerPos[1] + extraMargin);
                    }
                    legend.addMarker(mStyle, std::format("{:}{:}", MuonStationIndex::layerName(MuonStationIndex::toLayerIndex(chIdx)), 
                                                         isGood ? "" : " (discarded)"));
                    legend.addColor(mColor, msSector->barrel() ? "Barrel" : msSector->side() > 0 ? "Endcap A" : "Endcap C");
                }
            }
        }
        if (!drawnPoint) {
            canvas->trash();
            return;
        }
        for (const MsTrackSeed& seed : seeds) {
            const Amg::Vector3D& pos{seed.position()};
            canvas->add(drawMarker(viewVector(pos.phi(), Amg::Vector2D{pos.perp(), pos.z()}, view),
                                               kFullDiamond, kBlack));
            legend.addMarker(kFullDiamond, "track seed");
        }
        for (unsigned int s = 1; s<=16 ; ++s) {
            if (view != DisplayView::XY) {
                break;
            }
            const double phi =  sectorMap.sectorPhi(s);
            const double dPhi = sectorMap.sectorWidth(s);
 
            const int lStyle = s%2 ? kDashed : kDotted;
            const double r = canvas->corner(Edges::xHigh);
            const CxxUtils::sincos phiM{phi-dPhi}, phiP{phi+dPhi};
            const Amg::Vector2D e1{r * phiM.cs, r * phiM.sn};
            const Amg::Vector2D e2{r * phiP.cs, r * phiP.sn};
 
            auto theLine = std::make_unique<TLine>(0.,0., e1.x(), e1.y());
            theLine->SetLineStyle(lStyle);
            extPrimitives.insert(extPrimitives.begin(), std::move(theLine));
            theLine = std::make_unique<TLine>(0.,0., e2.x(), e2.y());
            theLine->SetLineStyle(lStyle);
            extPrimitives.insert(extPrimitives.begin(), std::move(theLine));
            theLine = std::make_unique<TLine>(e1.x(), e1.y(), e2.x(), e2.y());
            theLine->SetLineStyle(lStyle);
            extPrimitives.insert(extPrimitives.begin(), std::move(theLine));
        }
        legend.fillPrimitives(*canvas);
    }

displaySeeds() [2/3]

void MuonValR4::TrackVisualizationTool::displaySeeds ( const EventContext & ctx, const MuonR4::MsTrackSeeder & seederObj, const xAOD::MuonSegmentContainer & segments, const MuonR4::MsTrackSeedContainer & seeds ) const

finaloverridevirtual

Displays all segments on the representative cylinder in the R-Z & X-Y plane and draws the markers of the successfully built seeds & truth segments.

Parameters

ctx	EventContext to access store gate & conditions
seederObj	Configured instance of the track seeder which actually constructed the seeds.
segments	Container of all MS segments in the event
seeds	The constructed track seeds from the event

Definition at line 123 of file TrackVisualizationTool.cxx.

                                                                                       {
        displaySeeds(ctx, seederObj, segments, seeds, PrimitivesVec_t{});
    }

displaySeeds() [3/3]

void MuonValR4::TrackVisualizationTool::displaySeeds ( const EventContext & ctx, const MuonR4::MsTrackSeeder & seederObj, const xAOD::MuonSegmentContainer & segments, const MuonR4::MsTrackSeedContainer & seeds, PrimitivesVec_t && extPrimitives ) const

finaloverridevirtual

Displays all segments on the representative cylinder in the R-Z & X-Y plane and draws the markers of the successfully built seeds & truth segments.

Parameters

ctx	EventContext to access store gate & conditions
seederObj	Configured instance of the track seeder which actually constructed the seeds.
segments	Container of all MS segments in the event
extPrimitives	Extra TObjects that should be additionally painted onto the Canvases

Definition at line 129 of file TrackVisualizationTool.cxx.

                                                                                      {
        if (m_plotsDone || segments.empty()) {
            return;
        }
        displaySeeds(ctx, seederObj, DisplayView::RZ, segments, seeds, clone(extPrimitives));        
        displaySeeds(ctx, seederObj, DisplayView::XY, segments, seeds, std::move(extPrimitives));
    
    }

displayTrackSeedObj()

void MuonValR4::TrackVisualizationTool::displayTrackSeedObj ( const EventContext & ctx, const MuonR4::MsTrackSeed & seed, const OptBoundPars_t & parsToExt, const std::string & objName = "" ) const

finaloverridevirtual

Visualizes the measurements of the segments on the track seed together with their predicted local line parameters as an obj file.

If parameters to extrapolate are parsed, then they're extrapolated to the end of the world and the trajectory is added to the obj

Parameters

ctx	EventContext to fetch the conditions data & the event information
seed	MsTrack to visualize
parsToExt	Parameters to extrapolate on top
objName	Extra token to be added to the file name

Definition at line 296 of file TrackVisualizationTool.cxx.

                                                                                     {
        if (m_objCounter >= m_canvasLimit) {
            return;
        }
        const ActsTrk::GeometryContext* gctx{nullptr};
        SG::get(gctx, m_geoCtxKey, ctx).ignore();
 
        Acts::ObjVisualization3D visualHelper{};
        const std::string subDir = std::format("./ObjDisplays/{:}/", m_subDir.value());
        ensureDirectory(subDir);
        if (parsToExt.ok() && m_extrapolationTool.isEnabled()) {
            MuonValR4::drawPropagation(m_extrapolationTool->propagationSteps(ctx, *parsToExt).first,
                                       visualHelper);
        }
        std::string segStr{removeNonAlphaNum(objName)};
        for (const xAOD::MuonSegment* seg : seed.segments()) {
            MuonValR4::drawSegmentMeasurements(*gctx,* seg, visualHelper);
            MuonValR4::drawSegmentLine(*gctx,*seg, visualHelper);
            segStr += std::format("_{:}", MuonR4::printID(*seg));
        }
 
        unsigned fileVersion{0};
        std::string finalStr{};
        while (finalStr.empty() || std::filesystem::exists(finalStr)) {
            finalStr = std::format("{:}/{:}_{:}_{:}_{:}.obj", subDir, 
                m_clientToken.preFixName, ctx.eventID().event_number(), ++fileVersion, segStr);
        } 
        visualHelper.write(finalStr);
        ++m_objCounter;
    }

fillTruthSeedPoints()

void MuonValR4::TrackVisualizationTool::fillTruthSeedPoints ( const EventContext & ctx, const MuonR4::MsTrackSeeder & seeder, const DisplayView view, PlotLegend & legend, Canvas_t & canvas ) const

private

Add the truth segments to the canvas.

Parameters

ctx	EventContext to access store gate
seederObj	Configured instance of the track seeder which actually constructed the seeds.
view	Actual view to display
legend	Reference to the legend object to add the marker / truth legends
canvas	Reference to the canvas to which the drawn markers are appended to

Definition at line 251 of file TrackVisualizationTool.cxx.

                                                                             {
        const xAOD::MuonSegmentContainer* truthSegs{nullptr};
        if (!SG::get(truthSegs,m_truthSegKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Failed to fetch the truth segment container");
        }
        if (!truthSegs) {
            return;
        }
        const ActsTrk::GeometryContext* gctx{nullptr};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Failed to fetch the geometry context "<<m_geoCtxKey.fullKey());
        }
 
        bool addedEntry{false};
        for (const xAOD::MuonSegment* segment: *truthSegs) {
            const auto chIdx = segment->chamberIndex();
            const int mStyle = stationMarkerSyle(chIdx, false, true);
 
            using enum Location;
            using enum MsTrackSeeder::SectorProjector;
            for (const auto secProj : {leftOverlap, center, rightOverlap}) {
                if (!sectorMap.insideSector(segment->sector() + Acts::toUnderlying(secProj),
                                            segment->position().phi())){
                    continue;
                }
                for (const Location loc : {Barrel, Endcap}) {
                    const Amg::Vector2D projected{seeder.expressOnCylinder(*gctx, *segment, loc, secProj)};
                    if (!seeder.withinBounds(projected, loc)) {
                        continue;
                    }
                    const double phi = MsTrackSeeder::projectedPhi(segment->sector(), secProj);
                    canvas.add(drawMarker(viewVector(phi, projected, view), mStyle, truthColor, 3));
                    legend.addMarker(mStyle, Muon::MuonStationIndex::layerName(Muon::MuonStationIndex::toLayerIndex(chIdx)));
                    addedEntry = true;
                }
            }
        }
        if (addedEntry) {
            legend.addColor(truthColor, "truth");
        }
    }

initialize()

StatusCode MuonValR4::TrackVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 106 of file TrackVisualizationTool.cxx.

                                                  {
        if (m_canvasLimit > 0) {
            m_clientToken.canvasLimit = m_canvasLimit;
            m_clientToken.preFixName = m_canvasPrefix;
            m_clientToken.saveSinglePlots = m_saveSinglePDFs;
            m_clientToken.saveSummaryPlot = m_saveSummaryPDF;
            m_clientToken.subDirectory = m_subDir;
            ATH_CHECK(m_visualSvc.retrieve());
            ATH_CHECK(m_visualSvc->registerClient(m_clientToken));
        } else {
            m_plotsDone = true;
        }
        ATH_CHECK(m_truthSegKey.initialize(SG::AllowEmpty));
        ATH_CHECK(m_geoCtxKey.initialize());
        ATH_CHECK(m_extrapolationTool.retrieve(EnableTool{!m_extrapolationTool.empty()}));
        return StatusCode::SUCCESS;
    }

viewVector()

Amg::Vector2D MuonValR4::TrackVisualizationTool::viewVector ( const double phi, const Amg::Vector2D & posOnCylinder, const DisplayView view )

staticprivate

Transforms the projected vector into the actual view, if it's xy then an external phi is needed to place the marker.

Parameters

phi	Angle for the xy view - taken from the segment direction
posOnCylinder	Projection of the segment's position onto the seed cylinder
view	Actual view to display

Definition at line 96 of file TrackVisualizationTool.cxx.

                                                                             {
        using enum DisplayView;
        if (view == RZ) { 
            return Amg::Vector2D{ posOnCylinder[1]*inM,  posOnCylinder[0]*inM};
        }
        const CxxUtils::sincos phi{phiV};
        return posOnCylinder[0] * inM * Amg::Vector2D{phi.cs, phi.sn};
    }

Member Data Documentation

m_canvasLimit

Gaudi::Property<unsigned> MuonValR4::TrackVisualizationTool::m_canvasLimit {this, "CanvasLimit", 5000}

private

Maximum canvases to draw.

Definition at line 140 of file TrackVisualizationTool.h.

{this, "CanvasLimit", 5000};

m_canvasPrefix

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_canvasPrefix {this, "CanvasPreFix", "MsTrackValid"}

private

Prefix of the individual canvas file names <MANDATORY>

Definition at line 148 of file TrackVisualizationTool.h.

{this, "CanvasPreFix", "MsTrackValid"};

m_clientToken

IRootVisualizationService::ClientToken MuonValR4::TrackVisualizationTool::m_clientToken {}

private

Token to present to the visualization service such that the display froms this tool are grouped together.

Definition at line 134 of file TrackVisualizationTool.h.

{};

m_extrapolationTool

ToolHandle<ActsTrk::IExtrapolationTool> MuonValR4::TrackVisualizationTool::m_extrapolationTool {this, "ExtrapolationTool" ,"" }

private

Track extrapolation tool.

Definition at line 129 of file TrackVisualizationTool.h.

{this, "ExtrapolationTool" ,"" };

m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonValR4::TrackVisualizationTool::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Dependency on the geometry alignment.

Definition at line 138 of file TrackVisualizationTool.h.

{this, "AlignmentKey", "ActsAlignment", "cond handle key"};

m_objCounter

std::atomic<unsigned> MuonValR4::TrackVisualizationTool::m_objCounter {0}

mutableprivate

How many obj have been produced.

Definition at line 152 of file TrackVisualizationTool.h.

{0};

m_plotsDone

std::atomic<bool> MuonValR4::TrackVisualizationTool::m_plotsDone {false}

mutableprivate

Flag toggling whether all Canvases have been exhausted.

Definition at line 150 of file TrackVisualizationTool.h.

{false};

m_saveSinglePDFs

Gaudi::Property<bool> MuonValR4::TrackVisualizationTool::m_saveSinglePDFs {this, "saveSinglePDFs", true}

private

If set to true each canvas is saved into a dedicated pdf file.

Definition at line 142 of file TrackVisualizationTool.h.

{this, "saveSinglePDFs", true};

m_saveSummaryPDF

Gaudi::Property<bool> MuonValR4::TrackVisualizationTool::m_saveSummaryPDF {this, "saveSummaryPDF", true}

private

If set to true a summary Canvas is created.

Definition at line 144 of file TrackVisualizationTool.h.

{this, "saveSummaryPDF",  true};

m_subDir

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_subDir {this, "outSubDir", ""}

private

Define the subdirectory in which the plots shall be saved.

Definition at line 146 of file TrackVisualizationTool.h.

{this, "outSubDir", ""};

m_truthSegKey

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonValR4::TrackVisualizationTool::m_truthSegKey {this, "TruthSegkey", "MuonTruthSegments"}

private

Key to the truth segment selection to draw the segment parameters.

Definition at line 136 of file TrackVisualizationTool.h.

{this, "TruthSegkey", "MuonTruthSegments"};

m_visualSvc

ServiceHandle<IRootVisualizationService> MuonValR4::TrackVisualizationTool::m_visualSvc {this, "VisualSvc", "MuonValR4::RootVisualizationService"}

private

Service handle of the visualization service.

Definition at line 131 of file TrackVisualizationTool.h.

{this, "VisualSvc", "MuonValR4::RootVisualizationService"};

---

The documentation for this class was generated from the following files:

• TrackVisualizationTool.h
• TrackVisualizationTool.cxx