#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. More...

virtual StatusCode	initialize () override final

virtual StatusCode	finalize () override final

virtual void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds, const std::string &extraLabel) 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. More...

virtual void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds, const std::string &extraLabel, 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. More...

Private Types
enum	DisplayView { DisplayView::RZ, DisplayView::XY }
	Enumeration to toggle whether the seeds shall be painted in x-y or R-z view. More...

using	Location = MuonR4::MsTrackSeed::Location
	Enumeration to toggle whether the segment shall displayed on the barrel/endcap. More...

using	BoundBox_t = Acts::RangeXD< 2, double >
	Helper struct to determine the canvas ranges to be shown. More...

using	AxisLabels_t = std::tuple< std::string, std::string >
	tuple to declare the axis labels More...

Private Member Functions
std::unique_ptr< TCanvas >	makeCanvas (const EventContext &ctx, const BoundBox_t &bounds, const AxisLabels_t &axisLabels) const
	Creates a new TCanvas for drawing. More...

void	closeSummaryCanvas () const
	Closes the summary canvas & closes the associated ROOT file. More...

void	displaySeeds (const EventContext &ctx, const MuonR4::MsTrackSeeder &seederObj, const DisplayView view, const xAOD::MuonSegmentContainer &segments, const MuonR4::MsTrackSeedContainer &seeds, const std::string &extraLabel, PrimitivesVec_t &extPrimitives) const
	Actual implementation of the display seeds method with the augmentation to define the view. More...

void	fillTruthSeedPoints (const EventContext &ctx, const MuonR4::MsTrackSeeder &seeder, const DisplayView view, PlotLegend &legend, PrimitivesVec_t &drawPrim) const
	Add the truth segments to the canvas. More...

Static Private Member Functions
static BoundBox_t	emptyBounds ()
	Createes a new empty range box ready for shrinkin useage. More...

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. More...

Private Attributes
SG::ReadHandleKey< xAOD::MuonSegmentContainer >	m_truthSegKey {this, "TruthSegkey", "TruthSegmentsR4"}
	Key to the truth segment selection to draw the segment parameters. More...

Gaudi::Property< unsigned >	m_canvasLimit {this, "CanvasLimit", 5000}
	Maximum canvases to draw. More...

Gaudi::Property< bool >	m_saveSinglePDFs {this, "saveSinglePDFs", true}
	If set to true each canvas is saved into a dedicated pdf file. More...

Gaudi::Property< bool >	m_saveSummaryPDF {this, "saveSummaryPDF", false}
	If set to true a summary Canvas is created. More...

Gaudi::Property< std::string >	m_allCanName {this, "AllCanvasName", "AllMsTrackPlots"}
	Name of the summary canvas & the ROOT file to save the monitoring plots. More...

Gaudi::Property< std::string >	m_canvasPrefix {this, "CanvasPreFix", "MsTrackValid"}
	Prefix of the individual canvas file names <MANDATORY> More...

Gaudi::Property< unsigned >	m_canvasWidth {this, "CanvasWidth", 800}
	Canvas dimensions. More...

Gaudi::Property< unsigned >	m_canvasHeight {this, "CanvasHeight", 600}

Gaudi::Property< std::string >	m_AtlasLabel {this, "AtlasLabel", "Internal"}
	ATLAS label (Internal / Prelimnary / Simulation) More...

Gaudi::Property< std::string >	m_sqrtSLabel {this, "SqrtSLabel", "14"}
	Centre of mass energy label. More...

Gaudi::Property< std::string >	m_lumiLabel {this, "LumiLabel", ""}
	Luminosity label. More...

std::unique_ptr< TCanvas > m_summaryCan	ATLAS_THREAD_SAFE {}

std::unique_ptr< TFile > m_outFile	ATLAS_THREAD_SAFE {}

std::atomic< unsigned int > m_canvCounter	ATLAS_THREAD_SAFE {0}

Static Private Attributes
static std::mutex	s_mutex {}
	Abrivation of the helper struct to determine the Canvas dimensions. More...

Detailed Description

Definition at line 21 of file TrackVisualizationTool.h.

Member Typedef Documentation

◆ AxisLabels_t

using MuonValR4::TrackVisualizationTool::AxisLabels_t = std::tuple<std::string, std::string>

private

tuple to declare the axis labels

Definition at line 90 of file TrackVisualizationTool.h.

◆ BoundBox_t

using MuonValR4::TrackVisualizationTool::BoundBox_t = Acts::RangeXD<2, double>

private

Helper struct to determine the canvas ranges to be shown.

Definition at line 86 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 84 of file TrackVisualizationTool.h.

Member Enumeration Documentation

◆ DisplayView

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

101 {RZ, XY};

Constructor & Destructor Documentation

◆ ~TrackVisualizationTool()

virtual MuonValR4::TrackVisualizationTool::~TrackVisualizationTool ( )

virtualdefault

Destructor.

Member Function Documentation

◆ closeSummaryCanvas()

void MuonValR4::TrackVisualizationTool::closeSummaryCanvas ( ) const

private

Closes the summary canvas & closes the associated ROOT file.

Definition at line 93 of file TrackVisualizationTool.cxx.

                                                           {
         if (!m_outFile) return;
         ATH_MSG_INFO("Close summary pdf & root file "<<m_allCanName);
         if (m_summaryCan) {
             m_summaryCan->cd();
             m_summaryCan->SaveAs((m_allCanName +".pdf]").c_str());
             m_summaryCan.reset();
         }
         m_outFile.reset();
     }

◆ 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,
		const std::string &	extraLabel,
		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
extraLabel	Extra label to be put onto the top of the shown canvases
extPrimitives	Extra TObjects that should be additionally painted onto the Canvases

First add the truth points

Then we can add the

Draw the sector map

Definition at line 168 of file TrackVisualizationTool.cxx.

                                                                                   {
  
         const unsigned nPrim = extPrimitives.size();
         PlotLegend legend{0.005,0.005, 0.6,0.1};
         fillTruthSeedPoints(ctx, seeder, view, legend, extPrimitives);
         auto boundBox = emptyBounds();
               
         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();
             });
         };
            
  
         for (const xAOD::MuonSegment* segment: segments) {
             using enum Location;
             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);
             const double phi = segment->direction().phi();
             for (const Location loc : {Barrel, Endcap}) {
                 const Amg::Vector2D projPos{seeder.expressOnCylinder(*segment, loc)};
                 if (!seeder.withinBounds(projPos, loc)) {
                     continue;
                 }
                 const bool isGood = onSeed(segment, loc);
                 const int mStyle = stationMarkerSyle(chIdx, false, isGood);
                 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;
                     boundBox[0].expand(-r, r);
                     boundBox[1].expand(-r, r);
                 } else {
                     boundBox[0].expand(markerPos[0] - extraMargin, markerPos[0] + extraMargin);
                     boundBox[1].expand(markerPos[1] - 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");
             }
         }
         for (const MsTrackSeed& seed : seeds) {
             const Amg::Vector3D& pos{seed.position()};
             extPrimitives.emplace_back(drawMarker(viewVector(pos.phi(), Amg::Vector2D{pos.perp(), pos.z()}, view),
                                                   kFullDiamond, kBlack));
             legend.addMarker(kFullDiamond, "track seed");
         }
         const Muon::MuonSectorMapping sectorMap{};
         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 = boundBox[0].max();
             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() + nPrim, std::move(theLine));
             theLine = std::make_unique<TLine>(0.,0., e2.x(), e2.y());
             theLine->SetLineStyle(lStyle);
             extPrimitives.insert(extPrimitives.begin() + nPrim, std::move(theLine));
             theLine = std::make_unique<TLine>(e1.x(), e1.y(), e2.x(), e2.y());
             theLine->SetLineStyle(lStyle);
             extPrimitives.insert(extPrimitives.begin() + nPrim, std::move(theLine));
         }
         auto canvas = makeCanvas(ctx, boundBox, view == DisplayView::XY ?  
                                  std::tie("x [m]", "y [m]") : std::tie("z [m]", "R [m]"));
  
         for (auto& prim: extPrimitives){
            prim->Draw(); 
         }
         legend.legend->SetBorderSize(0);
         legend.legend->SetNColumns(4);
         legend.legend->Draw();
         std::stringstream canvasName{};
         canvasName<<m_canvasPrefix.value()<<"_"<<ctx.eventID().event_number()
                    <<"_SeedDisplay"<<(view == DisplayView::XY ? "XY" : "RZ");
         if (!extraLabel.empty()) canvasName<<"_"<<removeNonAlphaNum(extraLabel);
         ATH_MSG_VERBOSE("Save new plot "<<canvasName.str());
         if (m_saveSinglePDFs) {
             canvas->SaveAs(std::format("Plots/{:}/{:}.pdf", m_canvasPrefix.value(), canvasName.str()).c_str());
         }
         if (m_saveSummaryPDF) {
             canvas->SaveAs((m_allCanName+".pdf").c_str());
         }
         m_outFile->WriteObject(canvas.get(), canvasName.str().c_str());
     }

◆ displaySeeds() [2/3]

void MuonValR4::TrackVisualizationTool::displaySeeds	(	const EventContext &	ctx,
		const MuonR4::MsTrackSeeder &	seederObj,
		const xAOD::MuonSegmentContainer &	segments,
		const MuonR4::MsTrackSeedContainer &	seeds,
		const std::string &	extraLabel
	)		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
extraLabel	Extra label to be put onto the top of the shown canvases

Definition at line 140 of file TrackVisualizationTool.cxx.

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

◆ displaySeeds() [3/3]

void MuonValR4::TrackVisualizationTool::displaySeeds	(	const EventContext &	ctx,
		const MuonR4::MsTrackSeeder &	seederObj,
		const xAOD::MuonSegmentContainer &	segments,
		const MuonR4::MsTrackSeedContainer &	seeds,
		const std::string &	extraLabel,
		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
extraLabel	Extra label to be put onto the top of the shown canvases
extPrimitives	Extra TObjects that should be additionally painted onto the Canvases

Definition at line 147 of file TrackVisualizationTool.cxx.

                                                                                       {
         if (m_canvCounter >= m_canvasLimit || segments.empty()) {
             return;
         }
         std::lock_guard guard{s_mutex};
         if (m_canvCounter >= m_canvasLimit) {
             return;
         }
         unsigned int nPrim = extPrimitives.size();
         displaySeeds(ctx, seederObj, DisplayView::RZ, segments, seeds, extraLabel, extPrimitives);
         extPrimitives.resize(nPrim);
         displaySeeds(ctx, seederObj, DisplayView::XY, segments, seeds, extraLabel, extPrimitives);
         if ((++m_canvCounter) >= m_canvasLimit) {
             closeSummaryCanvas();
         }
     }

◆ emptyBounds()

TrackVisualizationTool::BoundBox_t MuonValR4::TrackVisualizationTool::emptyBounds ( )

staticprivate

Createes a new empty range box ready for shrinkin useage.

Definition at line 87 of file TrackVisualizationTool.cxx.

                                             {
         return BoundBox_t{std::array{1.e9,1.e9}, std::array{-1.e9,-1.e9}};
     }

◆ fillTruthSeedPoints()

void MuonValR4::TrackVisualizationTool::fillTruthSeedPoints	(	const EventContext &	ctx,
		const MuonR4::MsTrackSeeder &	seeder,
		const DisplayView	view,
		PlotLegend &	legend,
		PrimitivesVec_t &	drawPrim
	)		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
drawPrim	Reference to the primitives to drawn. The markers are added to this vector

Definition at line 274 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;
         }
         bool addedEntry{false};
         for (const xAOD::MuonSegment* segment: *truthSegs) {
             const auto chIdx = segment->chamberIndex();
             const int mStyle = stationMarkerSyle(chIdx, false, true);
             const double phi = segment->direction().phi();
  
             using enum Location;
             for (const Location loc : {Barrel, Endcap}) {
                 const Amg::Vector2D projected{seeder.expressOnCylinder(*segment, loc)};
                 if (!seeder.withinBounds(projected, loc)) {
                     continue;
                 }
                 drawPrim.push_back(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");
         }
     }

◆ finalize()

StatusCode MuonValR4::TrackVisualizationTool::finalize ( )

finaloverridevirtual

Definition at line 113 of file TrackVisualizationTool.cxx.

                                                 {
         closeSummaryCanvas();
         return StatusCode::SUCCESS;
     }

◆ initialize()

StatusCode MuonValR4::TrackVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 117 of file TrackVisualizationTool.cxx.

                                                   {
         if (m_canvasLimit > 0) {
             if (m_canvasPrefix.value().empty() || m_allCanName.value().empty()) {
                 ATH_MSG_FATAL("Please define "<<m_canvasPrefix<<" && "<<m_allCanName);
                 return StatusCode::FAILURE;
             }
             if (m_saveSummaryPDF) {
                 m_summaryCan = std::make_unique<TCanvas>("all", "all", m_canvasWidth, m_canvasHeight);        
                 m_summaryCan->SaveAs((m_allCanName +".pdf[").c_str());
             }
             m_outFile = std::make_unique<TFile>( (m_allCanName +".root").c_str(), "RECREATE");
             if (m_saveSinglePDFs) {
                 std::filesystem::create_directories("Plots/" + m_canvasPrefix);
             }
             gROOT->SetStyle("ATLAS");
             TStyle* plotStyle = gROOT->GetStyle("ATLAS");
             plotStyle->SetOptTitle(0);
             plotStyle->SetHistLineWidth(1.);
             plotStyle->SetPalette(kViridis);
         }
         ATH_CHECK(m_truthSegKey.initialize(SG::AllowEmpty));
         return StatusCode::SUCCESS;
     }

◆ makeCanvas()

std::unique_ptr< TCanvas > MuonValR4::TrackVisualizationTool::makeCanvas	(	const EventContext &	ctx,
		const BoundBox_t &	bounds,
		const AxisLabels_t &	axisLabels
	)		const

private

Creates a new TCanvas for drawing.

Parameters

ctx	EventContext to give the canvas a unique name
bounds	Array determining the x & y axis intervals
axisLabels	Labels to be shown on the x & y axis

Definition at line 308 of file TrackVisualizationTool.cxx.

                                                                                                       {
         std::stringstream canvasName{};
         canvasName<<name()<<"_"<<ctx.eventID().event_number()<<"_"<<m_canvCounter;
         ATH_MSG_VERBOSE("Create new canvas "<<canvasName.str());
         auto canvas = std::make_unique<TCanvas>(canvasName.str().c_str(), "all", m_canvasWidth, m_canvasHeight);
         canvas->cd();
         TH1F* frame = canvas->DrawFrame(bounds[0].min(), bounds[1].min(),bounds[0].max(), bounds[1].max());
         frame->GetXaxis()->SetTitle(std::get<0>(axisLabels).c_str());
         frame->GetYaxis()->SetTitle(std::get<1>(axisLabels).c_str());
         return canvas;
     }

◆ 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 103 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

◆ ATLAS_THREAD_SAFE [1/3]

std::unique_ptr<TCanvas> m_summaryCan MuonValR4::TrackVisualizationTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 163 of file TrackVisualizationTool.h.

◆ ATLAS_THREAD_SAFE [2/3]

std::unique_ptr<TFile> m_outFile MuonValR4::TrackVisualizationTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 164 of file TrackVisualizationTool.h.

◆ ATLAS_THREAD_SAFE [3/3]

std::atomic<unsigned int> m_canvCounter MuonValR4::TrackVisualizationTool::ATLAS_THREAD_SAFE {0}

mutableprivate

Definition at line 165 of file TrackVisualizationTool.h.

◆ m_allCanName

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_allCanName {this, "AllCanvasName", "AllMsTrackPlots"}

private

Name of the summary canvas & the ROOT file to save the monitoring plots.

Definition at line 148 of file TrackVisualizationTool.h.

◆ m_AtlasLabel

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_AtlasLabel {this, "AtlasLabel", "Internal"}

private

ATLAS label (Internal / Prelimnary / Simulation)

Definition at line 155 of file TrackVisualizationTool.h.

◆ m_canvasHeight

Gaudi::Property<unsigned> MuonValR4::TrackVisualizationTool::m_canvasHeight {this, "CanvasHeight", 600}

private

Definition at line 153 of file TrackVisualizationTool.h.

◆ m_canvasLimit

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

private

Maximum canvases to draw.

Definition at line 141 of file TrackVisualizationTool.h.

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

◆ m_canvasWidth

Gaudi::Property<unsigned> MuonValR4::TrackVisualizationTool::m_canvasWidth {this, "CanvasWidth", 800}

private

Canvas dimensions.

Definition at line 152 of file TrackVisualizationTool.h.

◆ m_lumiLabel

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_lumiLabel {this, "LumiLabel", ""}

private

Luminosity label.

Definition at line 159 of file TrackVisualizationTool.h.

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

◆ m_saveSummaryPDF

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

private

If set to true a summary Canvas is created.

ATTENTION: There can be only one summary PDF in an athena job

Definition at line 146 of file TrackVisualizationTool.h.

◆ m_sqrtSLabel

Gaudi::Property<std::string> MuonValR4::TrackVisualizationTool::m_sqrtSLabel {this, "SqrtSLabel", "14"}

private

Centre of mass energy label.

Definition at line 157 of file TrackVisualizationTool.h.

◆ m_truthSegKey

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

private

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

Definition at line 139 of file TrackVisualizationTool.h.

◆ s_mutex

std::mutex MuonValR4::TrackVisualizationTool::s_mutex {}

staticprivate

Abrivation of the helper struct to determine the Canvas dimensions.

Definition at line 162 of file TrackVisualizationTool.h.

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

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ AxisLabels_t

◆ BoundBox_t

◆ Location

Member Enumeration Documentation

◆ DisplayView

Constructor & Destructor Documentation

◆ ~TrackVisualizationTool()

Member Function Documentation

◆ closeSummaryCanvas()

◆ displaySeeds() [1/3]

◆ displaySeeds() [2/3]

◆ displaySeeds() [3/3]

◆ emptyBounds()

◆ fillTruthSeedPoints()

◆ finalize()

◆ initialize()

◆ makeCanvas()

◆ viewVector()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/3]

◆ ATLAS_THREAD_SAFE [2/3]

◆ ATLAS_THREAD_SAFE [3/3]

◆ m_allCanName

◆ m_AtlasLabel

◆ m_canvasHeight

◆ m_canvasLimit

◆ m_canvasPrefix

◆ m_canvasWidth

◆ m_lumiLabel

◆ m_saveSinglePDFs

◆ m_saveSummaryPDF

◆ m_sqrtSLabel

◆ m_truthSegKey

◆ s_mutex