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::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::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 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 DisplayView view, PlotLegend &legend, Canvas_t &canvas) const
	Add the truth segments to the canvas.
void	displaySeedSegmentsGlobalWithTruth (const EventContext &ctx, const DisplayView view, const MuonR4::MsTrackSeedContainer &seeds) const

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.
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
	Service handle to the tracking geometry 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.
ToolHandle< MuonR4::ITrackSeedingDiagnosticsTool >	m_seedingTool {this, "SeedingTool", ""}
	The track seeding tool to construct the seed candidates and to estimate the initial parameters.
SG::ReadHandleKey< xAOD::MuonSegmentContainer >	m_segmentKey {this, "SegmentContainer", "MuonSegmentsFromR4" }
	Declare the data dependency on the standard Mdt+Rpc+Tgc segment container & on the NSW segment container.
ActsTrk::ContextUtility	m_contextProvider {this}
	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 22 of file TrackVisualizationTool.h.

Member Typedef Documentation

Canvas_t

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

private

Definition at line 44 of file TrackVisualizationTool.h.

Edges

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

private

Definition at line 45 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 73 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 75 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 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
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 303 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, 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 Acts::GeometryContext tgContext = m_contextProvider.getGeometryContext(ctx);
        bool drawnPoint{false};
 
        for (const xAOD::MuonSegment* segment: segments) {
            using enum Location;
            using enum ExpandedSector::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}) {
                const ExpandedSector sector{static_cast<unsigned>(segment->sector()), secProj};
                if (ExpandedSector{segment->position().phi()} != sector){
                    continue;
                }
 
                for (const Location loc : {Barrel, Endcap}) {
                    const Amg::Vector2D projPos{m_seedingTool->expressOnCylinder(tgContext, *segment, loc, sector)};
                    if (!m_seedingTool->withinBounds(projPos, loc)) {
                        continue;
                    }
                    drawnPoint = true;
                    const bool isGood = onSeed(segment, loc);
                    const int mStyle = stationMarkerSyle(chIdx, true, isGood);
                    const Amg::Vector2D markerPos{viewVector(sector.phi(), projPos, view)};
                    extPrimitives.emplace_back( drawMarker(markerPos, mStyle, mColor)); //Is this necessary?
                    canvas->add( 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)"), mColor);
                    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::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
seeds	The constructed track seeds from the event

Definition at line 153 of file TrackVisualizationTool.cxx.

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

displaySeeds() [3/3]

void MuonValR4::TrackVisualizationTool::displaySeeds ( const EventContext & ctx, 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
seeds	The constructed track seeds from the event

Definition at line 157 of file TrackVisualizationTool.cxx.

                                                                                      {
        
        
        const xAOD::MuonSegmentContainer* segments{nullptr};
        if (m_plotsDone || !SG::get(segments, m_segmentKey, ctx) || segments->empty()) {
            return;
        }
 
        displaySeeds(ctx, DisplayView::RZ, *segments, seeds, clone(extPrimitives));        
        displaySeeds(ctx, DisplayView::XY, *segments, seeds, std::move(extPrimitives));
 
        //For each seed plot respective segment parameters
 
        displaySeedSegmentsGlobalWithTruth(ctx, DisplayView::RZ, seeds);
        displaySeedSegmentsGlobalWithTruth(ctx, DisplayView::XY, seeds);
    
    }

displaySeedSegmentsGlobalWithTruth()

void MuonValR4::TrackVisualizationTool::displaySeedSegmentsGlobalWithTruth ( const EventContext & ctx, const DisplayView view, const MuonR4::MsTrackSeedContainer & seeds ) const

private

Definition at line 177 of file TrackVisualizationTool.cxx.

                                             {
 
  auto canvas = m_visualSvc->prepareCanvas(
      ctx, m_clientToken,
      std::format("SeedSegsGlobalTruth{:}", 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};
 
  PrimitivesVec_t primitives{};
  bool drewAny{false};
 
  // -----------------------
  // (A) Draw TRUTH segments
  // -----------------------
  const xAOD::MuonSegmentContainer* truthSegs{nullptr};
  if (!SG::get(truthSegs, m_truthSegKey, ctx).isSuccess()) {
    THROW_EXCEPTION("Failed to fetch the truth segment container");
  }
  if (truthSegs) {
    for (const xAOD::MuonSegment* seg : *truthSegs) {
      if (!seg) continue;
 
      // Same station-based marker, but OPEN marker to visually separate truth vs reco
      const auto chIdx = seg->chamberIndex();
      const int mStyleTruth = stationMarkerSyle(chIdx, /*openMarker=*/true, /*onSeed=*/true);
 
      const Amg::Vector3D p = seg->position();
      const double x = p.x() * inM;
      const double y = p.y() * inM;
      const double z = p.z() * inM;
      const double r = std::hypot(x, y);
      const Amg::Vector2D plotPos =
          (view == DisplayView::XY) ? Amg::Vector2D{x, y}
                                   : Amg::Vector2D{z, r};
      primitives.emplace_back(drawMarker(plotPos, mStyleTruth, truthColor, /*mSize=*/3));
 
      //Plot direction of the segment as well
      const double dir_x = seg->direction().x() * inM;
      const double dir_y = seg->direction().y() * inM;
      const double dir_z = seg->direction().z() * inM;
      const Amg::Vector2D plotDir =
          (view == DisplayView::XY) ? Amg::Vector2D{dir_x, dir_y}
                                   : Amg::Vector2D{dir_z, std::hypot(dir_x, dir_y)};
      primitives.emplace_back(drawArrow2D(plotPos, plotDir, truthColor));
 
 
      legend.addMarker(
          mStyleTruth,
          std::string(Muon::MuonStationIndex::layerName(Muon::MuonStationIndex::toLayerIndex(chIdx))) + " (truth)", truthColor);
 
      canvas->expandPad(plotPos.x() - extraMargin, plotPos.y() - extraMargin);
      canvas->expandPad(plotPos.x() + extraMargin, plotPos.y() + extraMargin);
      drewAny = true;
    }
  }
 
  // ---------------------------------
  // (B) Draw RECO seed-associated segs
  // ---------------------------------
  for (std::size_t iSeed = 0; iSeed < seeds.size(); ++iSeed) {
    const MsTrackSeed& seed = seeds[iSeed];
    const int color = seedColorIdx(iSeed);
 
    std::string seedLabel = std::format("s{:d}: ", static_cast<int>(iSeed));
 
    for (const xAOD::MuonSegment* seg : seed.segments()) {
      if (!seg) continue;
 
      const auto chIdx = seg->chamberIndex();
      const int mStyle = stationMarkerSyle(chIdx, /*openMarker=*/false, /*onSeed=*/true);
 
      const Amg::Vector3D p = seg->position();
      const double x = p.x() * inM;
      const double y = p.y() * inM;
      const double z = p.z() * inM;
      const double r = std::hypot(x, y);
      const Amg::Vector2D plotPos =
          (view == DisplayView::XY) ? Amg::Vector2D{x, y}
                                   : Amg::Vector2D{z, r};
 
      primitives.emplace_back(drawMarker(plotPos, mStyle, color));
 
      //Plot direction of the segment as well
      const double dir_x = seg->direction().x() * inM;
      const double dir_y = seg->direction().y() * inM;
      const double dir_z = seg->direction().z() * inM;
      const Amg::Vector2D plotDir =
          (view == DisplayView::XY) ? Amg::Vector2D{dir_x, dir_y}
                                   : Amg::Vector2D{dir_z, std::hypot(dir_x, dir_y)};
      primitives.emplace_back(drawArrow2D(plotPos, plotDir, color));
 
      std::string label = printID(*seg);
      seedLabel += label + "_";
 
      primitives.emplace_back(MuonValR4::drawLabel(label, plotPos.x() + 0.01, plotPos.y() + 0.01, 10, false, color));
 
      // Marker legend: only one entry per station style (PlotLegend dedups)
      legend.addMarker(
          mStyle,
          std::string(Muon::MuonStationIndex::layerName(Muon::MuonStationIndex::toLayerIndex(chIdx))));
 
      canvas->expandPad(plotPos.x() - extraMargin, plotPos.y() - extraMargin);
      canvas->expandPad(plotPos.x() + extraMargin, plotPos.y() + extraMargin);
      drewAny = true;
    }
      //Add text which shows segment names associated to the respective seeed
      primitives.emplace_back(MuonValR4::drawLabel(seedLabel, 0.15, 0.9 - (0.03*iSeed), 10, true, color));
  }
 
  if (!drewAny) { canvas->trash(); return; }
 
  for (auto& p : primitives) canvas->add(std::move(p));
  legend.fillPrimitives(*canvas);
}

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 443 of file TrackVisualizationTool.cxx.

                                                                                     {
        if (m_objCounter >= m_canvasLimit) {
            return;
        }
        const Acts::GeometryContext tgContext = m_contextProvider.getGeometryContext(ctx);
        Acts::ObjVisualization3D visualHelper{};
        const std::string subDir = std::format("./ObjDisplays/{:}/", m_subDir.value());
        ensureDirectory(subDir);
 
        std::string segStr{removeNonAlphaNum(objName)};
        std::unordered_set<Acts::GeometryIdentifier> surfaceIds{};
        for (const xAOD::MuonSegment* seg : seed.segments()) {
            for (unsigned m = 0 ; m < nMeasurements(*seg) ; ++m) {
                surfaceIds.insert(xAOD::muonSurface(getMeasurement(*seg,m)).geometryId());
            }
            MuonValR4::drawSegmentMeasurements(tgContext,* seg, visualHelper);
            MuonValR4::drawSegmentLine(tgContext, *seg, visualHelper);
            segStr += std::format("_{:}", MuonR4::printID(*seg));
        }
 
        if (parsToExt.ok() && m_extrapolationTool.isEnabled()) {
            auto stepsResult = m_extrapolationTool->propagationSteps(ctx, *parsToExt);
            if (stepsResult.ok()) {
                const auto* vol = m_trackingGeometrySvc->trackingGeometry()->highestTrackingVolume();
 
                auto [begin, end] = std::ranges::remove_if(stepsResult->first,
                                    [vol](const Acts::detail::Step& step) {
                    return !vol->volumeBounds().inside(step.position);
                });
                stepsResult->first.erase(begin, end);
                for (const Acts::detail::Step& step: stepsResult->first) {
                    if (!step.surface || surfaceIds.count(step.surface->geometryId())) {
                        continue;
                    }
                    Acts::GeometryView3D::drawSurface(visualHelper, *step.surface, tgContext,
                                              Amg::Transform3D::Identity(), Acts::s_viewPassive);
                }
                MuonValR4::drawPropagation(stepsResult->first, visualHelper);
            } else {
                ATH_MSG_WARNING("Failed to extrapolate the seed for visualization: " << stepsResult.error().message());
            }
        }
 
        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 DisplayView view, PlotLegend & legend, Canvas_t & canvas ) const

private

Add the truth segments to the canvas.

Parameters

ctx	EventContext to access store gate
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 409 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 Acts::GeometryContext tgContext = m_contextProvider.getGeometryContext(ctx);
        bool addedEntry{false};
        for (const xAOD::MuonSegment* segment: *truthSegs) {
            const auto chIdx = segment->chamberIndex();
            const int mStyle = stationMarkerSyle(chIdx, true, true);
 
            using enum Location;
            using enum ExpandedSector::SectorProjector;
            ExpandedSector sector{segment->position().phi()};
            for (const Location loc : {Barrel, Endcap}) {
                const Amg::Vector2D projected{m_seedingTool->expressOnCylinder(tgContext, *segment, loc, sector)};
                if (!m_seedingTool->withinBounds(projected, loc)) {
                    continue;
                }
                canvas.add(drawMarker(viewVector(sector.phi(), projected, view), mStyle, truthColor, 3));
                legend.addMarker(mStyle, Muon::MuonStationIndex::layerName(Muon::MuonStationIndex::toLayerIndex(chIdx)), truthColor);
                addedEntry = true;
            }
        }
        if (addedEntry) {
            legend.addColor(truthColor, "truth");
        }
    }

initialize()

StatusCode MuonValR4::TrackVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 133 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_segmentKey.initialize());
        ATH_CHECK(m_contextProvider.initialize());
        ATH_CHECK(m_seedingTool.retrieve());
        ATH_CHECK(m_trackingGeometrySvc.retrieve());
        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 123 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 129 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 137 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 117 of file TrackVisualizationTool.h.

{};

m_contextProvider

ActsTrk::ContextUtility MuonValR4::TrackVisualizationTool::m_contextProvider {this}

private

Dependency on the geometry alignment.

Definition at line 127 of file TrackVisualizationTool.h.

{this};

m_extrapolationTool

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

private

Track extrapolation tool.

Definition at line 110 of file TrackVisualizationTool.h.

{this, "ExtrapolationTool" ,"" };

m_objCounter

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

mutableprivate

How many obj have been produced.

Definition at line 141 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 139 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 131 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 133 of file TrackVisualizationTool.h.

{this, "saveSummaryPDF",  true};

m_seedingTool

ToolHandle<MuonR4::ITrackSeedingDiagnosticsTool> MuonValR4::TrackVisualizationTool::m_seedingTool {this, "SeedingTool", ""}

private

The track seeding tool to construct the seed candidates and to estimate the initial parameters.

Definition at line 121 of file TrackVisualizationTool.h.

{this, "SeedingTool", ""};

m_segmentKey

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonValR4::TrackVisualizationTool::m_segmentKey {this, "SegmentContainer", "MuonSegmentsFromR4" }

private

Declare the data dependency on the standard Mdt+Rpc+Tgc segment container & on the NSW segment container.

Definition at line 124 of file TrackVisualizationTool.h.

{this, "SegmentContainer", "MuonSegmentsFromR4" };

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 135 of file TrackVisualizationTool.h.

{this, "outSubDir", ""};

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> MuonValR4::TrackVisualizationTool::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Service handle to the tracking geometry service.

Definition at line 114 of file TrackVisualizationTool.h.

{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

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 119 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 112 of file TrackVisualizationTool.h.

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

---

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

• TrackVisualizationTool.h
• TrackVisualizationTool.cxx