MuonValR4::PatternVisualizationTool Class Reference

#include <PatternVisualizationTool.h>

Inheritance diagram for MuonValR4::PatternVisualizationTool:

Collaboration diagram for MuonValR4::PatternVisualizationTool:

Public Types
using	TruthSegmentSet = std::unordered_set< const xAOD::MuonSegment * >

Public Member Functions
	PatternVisualizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () 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
virtual TruthSegmentSet	fetchTruthSegs (const std::vector< const MuonR4::SpacePoint * > &hits) const override final
	Fetches all truth segments where at least one measurement in the list was used to build them. More...
virtual TruthSegmentSet	fetchTruthSegs (const std::vector< const xAOD::UncalibratedMeasurement * > &hits) const override final
virtual bool	isTruthMatched (const MuonR4::SpacePoint &hit) const override final
	Returns whether the hit has been used in the truth-segment building. More...
virtual bool	isTruthMatched (const xAOD::UncalibratedMeasurement &hit) const override final
template<class SpacePointType >
const SpacePoint *	drawHit (const SpacePointType &hit, PrimitiveVec &primitives, std::array< double, 4 > &canvasDim, const unsigned int view, unsigned int fillStyle) const

Private Types
using	SegLink_t = ElementLink< xAOD::MuonSegmentContainer >
using	SegLinkVec_t = std::vector< SegLink_t >
using	SegLinkDecor_t = SG::AuxElement::ConstAccessor< SegLinkVec_t >

Private Member Functions
void	closeSummaryCanvas () const
	Closes the summary canvas & closes the associated ROOT file. More...
std::unique_ptr< TCanvas >	makeCanvas (const EventContext &ctx, const std::array< double, 4 > &canvasDim, const int view) const
	Create a new Canvas & draw the underlying frame. More...
void	saveCanvas (const EventContext &ctx, const Identifier &chambId, TCanvas &canvas, const std::string &extraLabel) const
	Saves the Canvas as pdf & also into the ROOT file. More...
template<class SpacePointType >
bool	drawHits (const MuonR4::SpacePointBucket &bucket, const std::vector< SpacePointType > &hitsToDraw, PrimitiveVec &primitivesToPush, std::array< double, 4 > &canvasDim, unsigned int view) const
	Translates the Spacepoint information into TObjects that are dawn on the canvas & evaluates the size of the box surrounding the event. More...
template<class SpacePointType >
const MuonR4::SpacePoint *	drawHit (const SpacePointType &hit, PrimitiveVec &primitives, std::array< double, 4 > &canvasDim, const unsigned int view, unsigned int fillStyle) const
	Converts a Hit into a particular TBox/ TEllipse for drawing. More...
template<class SpacePointType >
void	writeChi2 (const MuonR4::SegmentFit::Parameters &pars, const std::vector< SpacePointType > &hits, PrimitiveVec &primitivesToPush, const double legX=0.15, double startLegY=0.8, const double endLegY=0.3) const
	Writes the chi2 of the hits onto the Canvas. More...

Private Attributes
Gaudi::Property< unsigned int >	m_canvasLimit {this, "CanvasLimits", 5000}
	Maximum canvases to draw. More...
Gaudi::Property< bool >	m_saveSinglePDFs {this, "saveSinglePDFs", false}
	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", "AllPatternPlots"}
	Name of the summary canvas & the ROOT file to save the monitoring plots. More...
Gaudi::Property< std::string >	m_canvasPrefix {this, "CanvasPreFix", ""}
	Prefix of the individual canvas file names <MANDATORY> More...
Gaudi::Property< bool >	m_displayBucket {this, "displayBucket", true}
	Display the surrounding hits from the bucket not part of the seed. More...
Gaudi::Property< double >	m_canvasExtraScale {this, "CanvasExtraScale" , 1.3}
	Extra safety margin to zoom out from the Canvas. More...
Gaudi::Property< bool >	m_accumlIsEta {this, "AccumulatorsInEtaPlane", true}
	Swtich toggling whether the accumulator view are in the eta or phi plane. More...
Gaudi::Property< bool >	m_doEtaBucketViews {this,"doEtaBucketViews", true}
	Switch to visualize the eta view of the bucket event. More...
Gaudi::Property< bool >	m_doPhiBucketViews {this,"doPhiBucketViews", true}
	Switch to visualize the phi view of the bucket event. More...
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer >	m_prepContainerKeys {this, "PrdContainer", {}}
	Declare dependency on the prep data containers. More...
Gaudi::Property< std::set< std::string > >	m_truthSegLinks {this, "TruthSegDecors", {}}
	List of truth segment links to fetch. More...
SG::ReadDecorHandleKeyArray< xAOD::UncalibratedMeasurementContainer >	m_truthLinkDecorKeys {this, "LinkDecorKeys", {}}
	Declaration of the dependency on the decorations. More...
std::vector< SegLinkDecor_t >	m_truthLinkDecors {}
Gaudi::Property< unsigned >	m_canvasWidth {this, "CanvasWidth", 800}
Gaudi::Property< unsigned >	m_canvasHeight {this, "CanvasHeight", 600}
Gaudi::Property< bool >	m_displayOnlyTruth {this, "displayTruthOnly", false}
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	pointer to the Detector manager More...
SG::ReadHandleKey< ActsGeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Geometry context key to retrieve the alignment. More...
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Service Handle to the IMuonIdHelperSvc. More...
std::unique_ptr< TCanvas > m_allCan	ATLAS_THREAD_SAFE {}
std::unique_ptr< TFile > m_outFile	ATLAS_THREAD_SAFE {}
std::atomic< unsigned int > m_canvCounter	ATLAS_THREAD_SAFE {0}
	how many canvases have been visualized More...

Static Private Attributes
static std::mutex	s_mutex {}

Detailed Description

Definition at line 29 of file PatternVisualizationTool.h.

Member Typedef Documentation

SegLink_t

using MuonValR4::PatternVisualizationTool::SegLink_t = ElementLink<xAOD::MuonSegmentContainer>

private

Definition at line 189 of file PatternVisualizationTool.h.

SegLinkDecor_t

using MuonValR4::PatternVisualizationTool::SegLinkDecor_t = SG::AuxElement::ConstAccessor<SegLinkVec_t>

private

Definition at line 191 of file PatternVisualizationTool.h.

SegLinkVec_t

using MuonValR4::PatternVisualizationTool::SegLinkVec_t = std::vector<SegLink_t>

private

Definition at line 190 of file PatternVisualizationTool.h.

TruthSegmentSet

using MuonValR4::PatternVisualizationTool::TruthSegmentSet = std::unordered_set<const xAOD::MuonSegment*>

Definition at line 79 of file PatternVisualizationTool.h.

Constructor & Destructor Documentation

PatternVisualizationTool()

MuonValR4::PatternVisualizationTool::PatternVisualizationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 58 of file PatternVisualizationTool.cxx.

                                                                                                                            :
            base_class{type,name,parent} {}

Member Function Documentation

closeSummaryCanvas()

void MuonValR4::PatternVisualizationTool::closeSummaryCanvas ( ) const

private

Closes the summary canvas & closes the associated ROOT file.

Definition at line 639 of file PatternVisualizationTool.cxx.

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

drawHit() [1/2]

template<class SpacePointType >

const MuonR4::SpacePoint* MuonValR4::PatternVisualizationTool::drawHit ( const SpacePointType &  hit, PrimitiveVec &  primitives, std::array< double, 4 > &  canvasDim, const unsigned int  view, unsigned int  fillStyle  ) const

private

Converts a Hit into a particular TBox/ TEllipse for drawing.

If the hit provides information that's requested for that view. The underlying space pointer is returned and the dimensions of the canvas are updated, if the drawing was succesful

Parameters

hit	Reference to the hit to draw
primitives	Vector into which the generated object is pushed
canvasDim	Array encoding the canvas dimensions [0] -> low x; [1] -> high x, [2] -> low y, [3] -> high y
view	Draw the hit either in the eta or phi view,
fillStyle	Standard fill style for the box e.g. full.

drawHit() [2/2]

template<class SpacePointType >

const SpacePoint* MuonValR4::PatternVisualizationTool::drawHit	(	const SpacePointType &	hit,
		PrimitiveVec &	primitives,
		std::array< double, 4 > &	canvasDim,
		const unsigned int	view,
		unsigned int	fillStyle
	)		const

Don't draw any hit which is not participating in the view

Update the fill style accrodingly

Definition at line 450 of file PatternVisualizationTool.cxx.

                                                                            {
        
        static_assert(std::is_same_v<SpacePointType, SpacePoint> ||
                      std::is_same_v<SpacePointType, CalibratedSpacePoint>, "Only usual & calibrated space points are supported");
        if ((view == objViewEta && !hit.measuresEta()) || (view == objViewPhi && !hit.measuresPhi())) {
            return nullptr;
        }
        
        if (hit.type() != xAOD::UncalibMeasType::Other) {
            canvasDim[Edges::yLow] = std::min(canvasDim[Edges::yLow], hit.positionInChamber()[view] - hit.driftRadius());
            canvasDim[Edges::yHigh] = std::max(canvasDim[Edges::yHigh], hit.positionInChamber()[view] + hit.driftRadius());
            canvasDim[Edges::zLow] = std::min(canvasDim[Edges::zLow], hit.positionInChamber().z() - hit.driftRadius());
            canvasDim[Edges::zHigh] = std::max(canvasDim[Edges::zHigh], hit.positionInChamber().z() + hit.driftRadius());
        }
 
        const SpacePoint* underlyingSp{nullptr};
        constexpr int invalidCalibFill = 3305;
        if constexpr (std::is_same_v<SpacePointType, SpacePoint>) {
            underlyingSp = &hit;
            if (hit.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(hit.primaryMeasurement());
                if (dc->status() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                    fillStyle = invalidCalibFill;
                }
            }
        } else if constexpr(std::is_same_v<SpacePointType, CalibratedSpacePoint>) {
            underlyingSp = hit.spacePoint();
            if (hit.fitState() == CalibratedSpacePoint::State::Valid) {
                fillStyle  = fullFilling;
            } else if (hit.fitState() == CalibratedSpacePoint::State::FailedCalib) {
                fillStyle = invalidCalibFill;
            } else  {
                fillStyle = hatchedFilling;
            }
        }
        switch(hit.type()) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(underlyingSp->primaryMeasurement());
                primitives.push_back(drawDriftCircle(hit.positionInChamber(), dc->readoutElement()->innerTubeRadius(), 
                                                     kBlack, hollowFilling));
 
                const int circColor = isTruthMatched(*dc) ? truthColor : kBlue;                    
                primitives.push_back(drawDriftCircle(hit.positionInChamber(), hit.driftRadius(), circColor, fillStyle));
                break;
            } case xAOD::UncalibMeasType::RpcStripType: {
                const auto* meas{static_cast<const xAOD::RpcMeasurement*>(underlyingSp->primaryMeasurement())};
                const int boxColor = isTruthMatched(*meas) ? truthColor : kGreen +2;
                const double boxWidth = 0.5*std::sqrt(12)*underlyingSp->uncertainty()[view];
                primitives.push_back(drawBox(hit.positionInChamber(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                             boxColor, fillStyle));
                break; 
            } case xAOD::UncalibMeasType::TgcStripType: {
                const auto* meas{static_cast<const xAOD::TgcStrip*>(underlyingSp->primaryMeasurement())};
                const int boxColor = isTruthMatched(*meas) ? truthColor : kCyan + 2;
                const double boxWidth = 0.5*std::sqrt(12)*underlyingSp->uncertainty()[view];
                primitives.push_back(drawBox(hit.positionInChamber(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                             boxColor, fillStyle));
                break; 
            } case xAOD::UncalibMeasType::Other :{
                break;
            } default:
                ATH_MSG_WARNING("Please implement proper drawings of the new small wheel.. "<<__FILE__<<":"<<__LINE__);    
                break;
        }
        return underlyingSp;
    }

drawHits()

template<class SpacePointType >

bool MuonValR4::PatternVisualizationTool::drawHits ( const MuonR4::SpacePointBucket &  bucket, const std::vector< SpacePointType > &  hitsToDraw, PrimitiveVec &  primitivesToPush, std::array< double, 4 > &  canvasDim, unsigned int  view  ) const

private

Translates the Spacepoint information into TObjects that are dawn on the canvas & evaluates the size of the box surrounding the event.

Returns true if at least 2 objects were created.

Parameters

bucket	SpacePoint bucket from which the hits are taken. If the <DisplayBucket> is set true, the hits that were not in the subset are also painted with hollow filling
hitsToDraw	Primary hit collection to draw which are drawn with fullFillStyle
primitivesToPush	Output vector into which the painting objects are pushed_back
canvasDim	Array encoding the canvas dimensions [0] -> low x; [1] -> high x, [2] -> low y, [3] -> high y
view	Either the eta or the phi view?

Definition at line 522 of file PatternVisualizationTool.cxx.

                                                                         {
 
        canvasDim[Edges::yLow] = canvasDim[Edges::zLow] = 100. *Gaudi::Units::m;
        canvasDim[Edges::yHigh] = canvasDim[Edges::zHigh] = -100. *Gaudi::Units::m;
        
        SpacePointSet drawnPoints{};
        for (const SpacePointType& hit : hitsToDraw) {            
            drawnPoints.insert(drawHit(*hit, primitives, canvasDim, view, fullFilling));
        }
        if (m_displayBucket) {
            for (const SpacePointBucket::value_type& hit : bucket) {
                // Don't redraw the other points
                if (drawnPoints.count(hit.get())) {
                    continue;
                }
                drawHit(*hit, primitives, canvasDim, view, hollowFilling);
            } 
        }
        double width =  (canvasDim[Edges::yHigh] - canvasDim[Edges::yLow])*m_canvasExtraScale;
        double height = (canvasDim[Edges::zHigh] - canvasDim[Edges::zLow])*m_canvasExtraScale;
        if (height > width) width = height; 
        else height = width;
 
        const double midPointX = 0.5 * (canvasDim[Edges::yHigh] + canvasDim[Edges::yLow]);
        const double midPointY = 0.5 * (canvasDim[Edges::zHigh] + canvasDim[Edges::zLow]);
        canvasDim[Edges::yLow] = midPointX - 0.5 * width;
        canvasDim[Edges::zLow] = midPointY - 0.5 * height;
        canvasDim[Edges::yHigh] = midPointX + 0.5 * width;
        canvasDim[Edges::zHigh] = midPointY + 0.5 * height;        
        return drawnPoints.size() - drawnPoints.count(nullptr) > 1;
    }

fetchTruthSegs() [1/2]

TruthSegmentSet MuonValR4::PatternVisualizationTool::fetchTruthSegs ( const std::vector< const MuonR4::SpacePoint * > &  hits ) const

finaloverridevirtual

Fetches all truth segments where at least one measurement in the list was used to build them.

Parameters

hits	Vector of hits to search

Definition at line 113 of file PatternVisualizationTool.cxx.

                                                                                                                 {
        std::vector<const xAOD::UncalibratedMeasurement*> measurements{};
        measurements.reserve(2* hits.size());
        for (const SpacePoint* hit: hits) {
            measurements.push_back(hit->primaryMeasurement());
            if(hit->secondaryMeasurement()) {
                measurements.push_back(hit->secondaryMeasurement());
            }
        }
        return fetchTruthSegs(measurements);
    }

fetchTruthSegs() [2/2]

TruthSegmentSet MuonValR4::PatternVisualizationTool::fetchTruthSegs ( const std::vector< const xAOD::UncalibratedMeasurement * > &  hits ) const

finaloverridevirtual

Definition at line 124 of file PatternVisualizationTool.cxx.

                                                                                                                            {
        TruthSegmentSet truthSegs{};
        for (const xAOD::UncalibratedMeasurement* hit : hits) {
            for (const SegLinkDecor_t& decor: m_truthLinkDecors) {
                for (const SegLink_t& link : decor(*hit)) {
                    truthSegs.insert(*link);
                }
            }
        }
        return truthSegs;
    }

finalize()

StatusCode MuonValR4::PatternVisualizationTool::finalize ( )

finaloverridevirtual

Definition at line 98 of file PatternVisualizationTool.cxx.

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

initialize()

StatusCode MuonValR4::PatternVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 61 of file PatternVisualizationTool.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_allCan = std::make_unique<TCanvas>("all", "all", m_canvasWidth, m_canvasHeight);        
                m_allCan->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);
            }
        }
        ATH_CHECK(m_prepContainerKeys.initialize(!m_truthSegLinks.empty()));
        m_truthLinkDecorKeys.clear();
        ATH_MSG_INFO("Hits linked to the following segment decorations are considered as truth");
        for (const std::string& decorName : m_truthSegLinks) {
            ATH_MSG_INFO(" **** "<<decorName);
            if (decorName.empty()) {
                ATH_MSG_FATAL("Decoration must not be empty");
                return StatusCode::FAILURE;
            }
            for (const SG::ReadHandleKey<xAOD::UncalibratedMeasurementContainer>& key : m_prepContainerKeys) {
                m_truthLinkDecorKeys.emplace_back(key, decorName);
                m_truthLinkDecors.push_back(SegLinkDecor_t{decorName});
            }
        }
        ATH_CHECK(m_truthLinkDecorKeys.initialize());
        m_displayOnlyTruth.value() &= !m_truthLinkDecorKeys.empty();
 
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_geoCtxKey.initialize());
        ATH_CHECK(detStore()->retrieve(m_detMgr));
        return StatusCode::SUCCESS;
    }

isTruthMatched() [1/2]

bool MuonValR4::PatternVisualizationTool::isTruthMatched ( const MuonR4::SpacePoint &  hit ) const

finaloverridevirtual

Returns whether the hit has been used in the truth-segment building.

Parameters

hit	Reference to the hit to check

Definition at line 102 of file PatternVisualizationTool.cxx.

                                                                                   {
        return isTruthMatched(*hit.primaryMeasurement()) || 
              (hit.secondaryMeasurement() && isTruthMatched(*hit.secondaryMeasurement()));
    }

isTruthMatched() [2/2]

bool MuonValR4::PatternVisualizationTool::isTruthMatched ( const xAOD::UncalibratedMeasurement &  hit ) const

finaloverridevirtual

Definition at line 106 of file PatternVisualizationTool.cxx.

                                                                                              {
        return std::find_if(m_truthLinkDecors.begin(), m_truthLinkDecors.end(),
                            [&hit](const SegLinkDecor_t& decor){
                                return !decor(hit).empty();
                            }) != m_truthLinkDecors.end();
    }

makeCanvas()

std::unique_ptr< TCanvas > MuonValR4::PatternVisualizationTool::makeCanvas ( const EventContext &  ctx, const std::array< double, 4 > &  canvasDim, const int  view  ) const

private

Create a new Canvas & draw the underlying frame.

Parameters

ctx	EventContext to generate a unique canvas name
canvasDim	Array encoding the canvas dimensions [0] -> low x; [1] -> high x, [2] -> low y, [3] -> high y
view	Is the canvas created in the context of an eta or phi visualization view The x-axis of the frame is adapted accordingly

Definition at line 649 of file PatternVisualizationTool.cxx.

                                                                                        {
        std::stringstream canvasName{};
        canvasName<<name()<<"_"<<ctx.eventID().event_number()<<"_"<<m_canvCounter;
        ATH_MSG_VERBOSE("Create new canvas "<<canvasName.str()<<" "<<canvasDim);
        auto canvas = std::make_unique<TCanvas>(canvasName.str().c_str(), "all", m_canvasWidth, m_canvasHeight);
        canvas->cd();
        TH1F* frame = canvas->DrawFrame(canvasDim[Edges::yLow],canvasDim[Edges::zLow], canvasDim[Edges::yHigh], canvasDim[Edges::zHigh]);
        frame->GetXaxis()->SetTitle(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x').c_str());
        frame->GetYaxis()->SetTitle("z [mm]");
        return canvas;
    }

saveCanvas()

void MuonValR4::PatternVisualizationTool::saveCanvas ( const EventContext &  ctx, const Identifier &  chambId, TCanvas &  canvas, const std::string &  extraLabel  ) const

private

Saves the Canvas as pdf & also into the ROOT file.

If the canvase limit is reached, then the summary files are closed as well.

Parameters

ctx	EventContext to fetch the event number
chambId	Identifier of the chamber from which the hits are stemming from
primtives	List of objects to draw onto the canvas
extraLabel	Externally passed extra label

Definition at line 662 of file PatternVisualizationTool.cxx.

                                                                                 {
        // If an eta view closes the summary canvas & a phi view is processed
        std::stringstream canvasName{};
        canvasName<<m_canvasPrefix.value()<<"_"<<ctx.eventID().event_number()<<"_"<<(m_canvCounter++)<<"_"
                  <<m_idHelperSvc->stationNameString(chambId)
                  <<std::abs(m_idHelperSvc->stationEta(chambId))
                  <<(m_idHelperSvc->stationEta(chambId) >0 ? "A" : "C")
                  <<m_idHelperSvc->stationPhi(chambId);
        if (!extraLabel.empty()) canvasName<<"_"<<removeNonAlphaNum(extraLabel);
        ATH_MSG_VERBOSE("Save new plot "<<canvasName.str());
        if (m_saveSinglePDFs) {
            canvas.SaveAs(("Plots/" + m_canvasPrefix+"/" + canvasName.str()+".pdf").c_str());
        }
        if (m_saveSummaryPDF) {
            canvas.SaveAs((m_allCanName+".pdf").c_str());
        }
        m_outFile->WriteObject(&canvas, canvasName.str().c_str());
    }

visualizeAccumulator() [1/2]

void MuonValR4::PatternVisualizationTool::visualizeAccumulator ( const EventContext &  ctx, const MuonR4::HoughPlane &  accumulator, const Acts::HoughTransformUtils::HoughAxisRanges &  axisRanges, const MaximumVec &  maxima, const std::string &  extraLabel  ) const

finaloverridevirtual

Definition at line 135 of file PatternVisualizationTool.cxx.

                                                                                           {
        PrimitiveVec primitives{};
        visualizeAccumulator(ctx, accumulator, axisRanges, maxima, extraLabel, std::move(primitives));
    }

visualizeAccumulator() [2/2]

void MuonValR4::PatternVisualizationTool::visualizeAccumulator ( const EventContext &  ctx, const MuonR4::HoughPlane &  accumulator, const Acts::HoughTransformUtils::HoughAxisRanges &  axisRanges, const MaximumVec &  maxima, const std::string &  extraLabel, PrimitiveVec &&  extraPaints  ) const

finaloverridevirtual

Check whether the canvas limit has been reached

Enter the lock phase

Check again in case multiple threads are simultaneously in the lock phase

Definition at line 143 of file PatternVisualizationTool.cxx.

                                                                                         {
 
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        if (accumulator.getNonEmptyBins().empty()) {
            ATH_MSG_WARNING("Hough accumulator is empty");
            return;
        }
 
        auto accHisto = std::make_unique<TH2F>("AccumulatorHisto", "histo",
                                                accumulator.nBinsX(), axisRanges.xMin, axisRanges.xMax,
                                                accumulator.nBinsY(), axisRanges.yMin, axisRanges.yMax); 
 
        accHisto->SetDirectory(nullptr);
        accHisto->GetXaxis()->SetTitle(std::format("tan #{}", m_accumlIsEta ? "theta" : "phi" ).c_str());
        accHisto->GetYaxis()->SetTitle( std::string{m_accumlIsEta ? "y_{0}" : "x_{0}"}.c_str());
 
        std::vector<const SpacePoint*> spacePointsInAcc{};
        for (const std::size_t bin : accumulator.getNonEmptyBins()) {
            const auto [xBin, yBin] = accumulator.axisBins(bin);
            const SpacePointSet& hitsInBin{accumulator.hitIds(xBin, yBin)};
            spacePointsInAcc.insert(spacePointsInAcc.end(),hitsInBin.begin(), hitsInBin.end());
            accHisto->SetBinContent(xBin+1, yBin+1, accumulator.nHits(bin));
        }
 
        const TruthSegmentSet truthSegs{fetchTruthSegs(spacePointsInAcc)};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        for (const xAOD::MuonSegment* segment : truthSegs) {
            const auto [pos, dir] = makeLine(localSegmentPars(*segment));
            const double tan = m_accumlIsEta ? houghTanTheta(dir) : houghTanPhi(dir);
            const double icept = pos[m_accumlIsEta ? objViewEta : objViewPhi];
            auto truthMarker = std::make_unique<TMarker>(tan, icept, kFullCrossX);
            truthMarker->SetMarkerColor(truthColor);
            truthMarker->SetMarkerSize(8);
            primitives.push_back(std::move(truthMarker));
        }
        for (const auto& maximum : maxima) {
            auto maxMarker = std::make_unique<TMarker>(maximum.x, maximum.y, kFullTriangleUp);
            maxMarker->SetMarkerColor(parLineColor);
            maxMarker->SetMarkerSize(8);
            primitives.push_back(std::move(maxMarker));
        }
        
        std::stringstream canvasName{};
        canvasName<<name()<<"_"<<ctx.eventID().event_number()<<"_"<<m_canvCounter;
        auto canvas = std::make_unique<TCanvas>(canvasName.str().c_str(), 
                                                 "can", m_canvasWidth, m_canvasHeight);
        canvas->cd();
        accHisto->Draw("COLZ");
        for (auto& prim : primitives) {
            prim->Draw();
        }
        primitives.push_back(std::move(accHisto));
        saveCanvas(ctx, spacePointsInAcc.front()->identify(), *canvas, extraLabel);
        primitives.push_back(std::move(canvas));
 
        primitives.clear();        
        if (m_canvasLimit <= m_canvCounter) {
            closeSummaryCanvas();
        }
    }

visualizeBucket() [1/2]

void MuonValR4::PatternVisualizationTool::visualizeBucket ( const EventContext &  ctx, const MuonR4::SpacePointBucket &  bucket, const std::string &  extraLabel  ) const

finaloverridevirtual

Definition at line 295 of file PatternVisualizationTool.cxx.

                                                                                       {
        PrimitiveVec primitives{};
        visualizeBucket(ctx, bucket, extraLabel, std::move(primitives));
    }

visualizeBucket() [2/2]

void MuonValR4::PatternVisualizationTool::visualizeBucket ( const EventContext &  ctx, const MuonR4::SpacePointBucket &  bucket, const std::string &  extraLabel, PrimitiveVec &&  extraPaints  ) const

finaloverridevirtual

Check whether the canvas limit has been reached

Enter the lock phase

Check again in case multiple threads are simultaneously in the lock phase

reset the primitives

Definition at line 301 of file PatternVisualizationTool.cxx.

                                                                                    {
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::array<double, 4> canvasDim{};        
        TruthSegmentSet truthSegs{fetchTruthSegs(stripSmartPtr(bucket))};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        const std::size_t parsedPrimSize{primitives.size()};
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            primitives.resize(parsedPrimSize);
            if (!drawHits(bucket, bucket, primitives, canvasDim, view)) {
                continue;
            }
            bool drawnTrueLabel{false};
            for (const xAOD::MuonSegment* segment : truthSegs) {
                primitives.push_back(drawLine(localSegmentPars(*segment), canvasDim[Edges::zLow], canvasDim[Edges::zHigh],
                                           truthColor, kDotted, view));
                if (!drawnTrueLabel) {
                    primitives.push_back(drawLabel(std::format("true parameters: {:}",makeLabel(localSegmentPars(*segment))),0.2, 0.91,14));
                    drawnTrueLabel = true;
                }
            }
            
            std::stringstream legendLabel{};
            legendLabel<<"Event: "<<ctx.eventID().event_number()
                        <<", chamber : "<<m_idHelperSvc->toStringChamber(bucket.front()->identify())
                        <<",#"<<(view ==objViewEta ? "eta" : "phi")<<"-view";
            if (!extraLabel.empty()) {
                legendLabel<<" ("<<extraLabel<<")";
            }
            primitives.push_back(drawLabel(legendLabel.str(), 0.2, 0.96));
            auto can = makeCanvas(ctx , canvasDim, view);
            for (PrimitivePtr& prim : primitives) {
                prim->Draw();
            }
            saveCanvas(ctx, bucket.front()->identify(), *can, extraLabel);
        }
        if (m_canvasLimit <= m_canvCounter) {
            primitives.clear();
            closeSummaryCanvas();
        }
 
    }

visualizeSeed() [1/2]

void MuonValR4::PatternVisualizationTool::visualizeSeed ( const EventContext &  ctx, const MuonR4::SegmentSeed &  seed, const std::string &  extraLabel  ) const

finaloverridevirtual

Definition at line 220 of file PatternVisualizationTool.cxx.

                                                                                    {
        PrimitiveVec primitives{};
        visualizeSeed(ctx, seed, extraLabel, std::move(primitives)); 
    }

visualizeSeed() [2/2]

void MuonValR4::PatternVisualizationTool::visualizeSeed ( const EventContext &  ctx, const MuonR4::SegmentSeed &  seed, const std::string &  extraLabel, PrimitiveVec &&  extraPaints  ) const

finaloverridevirtual

Check whether the canvas limit has been reached

Enter the lock phase

Check again in case multiple threads are simultaneously in the lock phase

reset the primitives

Definition at line 226 of file PatternVisualizationTool.cxx.

                                                                                  {
        
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
 
        const TruthSegmentSet truthSegs{fetchTruthSegs(seed.getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
 
        std::array<double, 4> canvasDim{};
        const std::size_t parsedPrimSize{primitives.size()};
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            primitives.resize(parsedPrimSize);
 
            if (!drawHits(*seed.parentBucket(), seed.getHitsInMax(), primitives, canvasDim, view)) {
                continue;
            }
 
            for (const xAOD::MuonSegment* segment : truthSegs) {
                primitives.push_back(drawLine(localSegmentPars(*segment), canvasDim[Edges::zLow], canvasDim[Edges::zHigh],
                                               truthColor, kDotted, view));
            }
            primitives.push_back(drawLine(seed.parameters(), canvasDim[Edges::zLow], canvasDim[Edges::zHigh],
                                         parLineColor, kDashed, view));
        
            writeChi2(seed.parameters(), seed.getHitsInMax(), primitives);
        
            std::stringstream legendLabel{};
            double chi2{0.};
            unsigned nDoF{0};
            legendLabel<<"Event: "<<ctx.eventID().event_number()<<", chamber : "<<m_idHelperSvc->toStringChamber(seed.getHitsInMax().front()->identify())
                       <<" #chi^{2} /nDoF: "<<std::format("{:.2f}", chi2/std::max(1u, nDoF))
                       <<", nDoF: "<<nDoF<<", #"<<(view ==objViewEta ? "eta" : "phi")<<"-view";;
            
            if (!extraLabel.empty()) {
                legendLabel<<" ("<<extraLabel<<")";
            }
            primitives.push_back(drawLabel(legendLabel.str(), 0.1, 0.96));
            primitives.push_back(drawLabel(makeLabel(seed.parameters()),0.25, 0.91));
        
            auto canvas = makeCanvas(ctx, canvasDim, view);
            for (PrimitivePtr& prim : primitives) {
               prim->Draw();
            }
            saveCanvas(ctx, seed.getHitsInMax().front()->identify(), *canvas, extraLabel);
        }
        if (m_canvasLimit <= m_canvCounter) {
            primitives.clear();
            closeSummaryCanvas();
        }
    }

visualizeSegment() [1/2]

void MuonValR4::PatternVisualizationTool::visualizeSegment ( const EventContext &  ctx, const MuonR4::Segment &  segment, const std::string &  extraLabel  ) const

finaloverridevirtual

Definition at line 362 of file PatternVisualizationTool.cxx.

                                                                                       {
        PrimitiveVec primitives{};
        visualizeSegment(ctx, segment,extraLabel, std::move(primitives));
    }

visualizeSegment() [2/2]

void MuonValR4::PatternVisualizationTool::visualizeSegment ( const EventContext &  ctx, const MuonR4::Segment &  segment, const std::string &  extraLabel, PrimitiveVec &&  extraPaints  ) const

finaloverridevirtual

Check whether the canvas limit has been reached

Enter the lock phase

Check again in case multiple threads are simultaneously in the lock phase

reset the primitives

Definition at line 369 of file PatternVisualizationTool.cxx.

                                                                                     {
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        const TruthSegmentSet truthSegs{fetchTruthSegs(segment.parent()->getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        Parameters segPars{};
        {
            SG::ReadHandle geoCtx{m_geoCtxKey, ctx};
            const Amg::Transform3D trf{segment.msSector()->globalToLocalTrans(*geoCtx)};
            const Amg::Vector3D locPos = trf * segment.position();
            const Amg::Vector3D locDir = trf.linear() * segment.direction();
            segPars[toInt(ParamDefs::x0)] = locPos.x();
            segPars[toInt(ParamDefs::y0)] = locPos.y();
            segPars[toInt(ParamDefs::theta)] = locDir.theta();
            segPars[toInt(ParamDefs::phi)] = locDir.phi();
            segPars[toInt(ParamDefs::time)] = segment.segementT0();
        }
        
        std::array<double, 4> canvasDim{};
        const std::size_t parsedPrimSize{primitives.size()};
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            primitives.resize(parsedPrimSize);
 
            if (!drawHits(*segment.parent()->parentBucket(), segment.measurements(), 
                          primitives, canvasDim, view)) {
                continue;
            }
            for (const xAOD::MuonSegment* segment : truthSegs) {
                primitives.push_back(drawLine(localSegmentPars(*segment), canvasDim[Edges::zLow], canvasDim[Edges::zHigh],
                                           truthColor, kDotted, view));
            }
            writeChi2(segPars, segment.measurements(), primitives);
 
            primitives.push_back(drawLine(segPars, canvasDim[Edges::zLow], canvasDim[Edges::zHigh],
                                          parLineColor, kDashed, view));
 
 
            std::stringstream legendLabel{};
            const Identifier canvasId{segment.parent()->getHitsInMax().front()->identify()};
            legendLabel<<"Event: "<<ctx.eventID().event_number() <<", chamber : "<<m_idHelperSvc->toStringChamber(canvasId)
                         <<", #chi^{2} /nDoF: "<<std::format("{:.2f} ({:d})", segment.chi2() /std::max(1u, segment.nDoF()), segment.nDoF())
                        <<", #"<<(view ==objViewEta ? "eta" : "phi")<<"-view";
 
            if (!extraLabel.empty()) {
                legendLabel<<" ("<<extraLabel<<")";
            }
            primitives.push_back(drawLabel(legendLabel.str(), 0.1, 0.96));
            primitives.push_back(drawLabel(makeLabel(segPars),0.25, 0.91));
 
            auto canvas = makeCanvas(ctx, canvasDim, view);
            for (PrimitivePtr& prim : primitives) {
                prim->Draw();
            }
            saveCanvas(ctx, canvasId, *canvas, extraLabel);
        }
        if (m_canvasLimit <= m_canvCounter) {
            primitives.clear();
            closeSummaryCanvas();
        }
    }

writeChi2()

template<class SpacePointType >

void MuonValR4::PatternVisualizationTool::writeChi2 ( const MuonR4::SegmentFit::Parameters &  pars, const std::vector< SpacePointType > &  hits, PrimitiveVec &  primitivesToPush, const double  legX = 0.15, double  startLegY = 0.8, const double  endLegY = 0.3  ) const

private

Writes the chi2 of the hits onto the Canvas.

Parameters

pars	Parameter for which the chi2 is evaluated,
hits	Vector of hits to consider
primitivesToPush	Output vector into which the TLabels are pushed for later drawing
legX	x-position of the list
statLegY	y-position of the first entry. The next one is 0.05 apart
endLeg	y-position of the last shown entry. The routine aborts if there're more hits in the event.

Definition at line 558 of file PatternVisualizationTool.cxx.

                                                                             {
        
        const auto [locPos, locDir] = makeLine(pars);
        for (const SpacePointType& hit : hits) { 
            const SpacePoint* underlyingSp{nullptr};
            double chi2{0.};
            if constexpr( std::is_same_v<SpacePointType, Segment::MeasType>) {
                underlyingSp = hit->spacePoint();
                chi2 = SegmentFitHelpers::chiSqTerm(locPos, locDir, pars[toInt(AxisDefs::t0)], 
                                                    std::nullopt, *hit, msgStream());
            } else {
                underlyingSp = hit;
                chi2  = SegmentFitHelpers::chiSqTerm(locPos, locDir, *hit, msgStream());
            }
            
            const Identifier hitId =  underlyingSp ? underlyingSp->identify(): Identifier{};
            std::stringstream legendstream{};
            switch(hit->type()) {
                case xAOD::UncalibMeasType::MdtDriftCircleType: {
                    const int driftSign{SegmentFitHelpers::driftSign(locPos, locDir, *hit, msgStream())};
                    const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
                    legendstream<<"ML: "<<idHelper.multilayer(hitId);
                    legendstream<<", TL: "<<idHelper.tubeLayer(hitId);
                    legendstream<<", T: "<<idHelper.tube(hitId);
                    legendstream<<", "<<(driftSign == -1 ? "L" : "R");
                    break;
                } case xAOD::UncalibMeasType::RpcStripType: {
                    const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
                    legendstream<<"DR: "<<idHelper.doubletR(hitId);
                    legendstream<<" DZ: "<<idHelper.doubletZ(hitId);
                    legendstream<<", GAP: "<<idHelper.gasGap(hitId);
                    legendstream<<", #eta/#phi: "<<(hit->measuresEta() ? "si" : "nay") 
                                << "/"<<(hit->measuresPhi() ? "si" : "nay");
                    break;
                } case xAOD::UncalibMeasType::TgcStripType: {
                    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
                    legendstream<<"ST: "<<m_idHelperSvc->stationNameString(hitId);
                    legendstream<<", GAP: "<<idHelper.gasGap(hitId);
                    legendstream<<", #eta/#phi: "<<(hit->measuresEta() ? "si" : "nay") 
                                 << "/"<<(hit->measuresPhi() ? "si" : "nay");      
                    break;
                } case xAOD::UncalibMeasType::MMClusterType: {
                    const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
                    legendstream<<"ML: "<<idHelper.multilayer(hitId);
                    legendstream<<", GAP: "<<idHelper.gasGap(hitId);
                    legendstream<<", stereo: "<<(idHelper.isStereo(hitId)? "si" : "nay");
                    break;
                } case xAOD::UncalibMeasType::sTgcStripType: {
                    const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
                    legendstream<<"ML: "<<idHelper.multilayer(hitId);
                    legendstream<<", GAP: "<<idHelper.gasGap(hitId);
                    switch (idHelper.channelType(hitId)) {
                        case sTgcIdHelper::sTgcChannelTypes::Strip:
                            legendstream<<", strip";
                            break;
                        case sTgcIdHelper::sTgcChannelTypes::Wire:
                            legendstream<<", wire";
                            break;
                        case sTgcIdHelper::sTgcChannelTypes::Pad:
                            legendstream<<", pad";
                            break;
                        default:
                            break;
                    }
                    break;
                } 
                default:
                    break;
            }
            legendstream<<", #chi^{2}: "<<std::format("{:.2f}", chi2);
            primitives.push_back(drawLabel(legendstream.str(), legX, startLegY, 14));
            startLegY -= 0.05;
            if (startLegY<= endLegY) {
                break;
            }
        }
    }

Member Data Documentation

ATLAS_THREAD_SAFE [1/3]

std::unique_ptr<TCanvas> m_allCan MuonValR4::PatternVisualizationTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 208 of file PatternVisualizationTool.h.

ATLAS_THREAD_SAFE [2/3]

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

mutableprivate

Definition at line 209 of file PatternVisualizationTool.h.

ATLAS_THREAD_SAFE [3/3]

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

mutableprivate

how many canvases have been visualized

Definition at line 211 of file PatternVisualizationTool.h.

m_accumlIsEta

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_accumlIsEta {this, "AccumulatorsInEtaPlane", true}

private

Swtich toggling whether the accumulator view are in the eta or phi plane.

Just affects the axis labels

Definition at line 178 of file PatternVisualizationTool.h.

m_allCanName

Gaudi::Property<std::string> MuonValR4::PatternVisualizationTool::m_allCanName {this, "AllCanvasName", "AllPatternPlots"}

private

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

Definition at line 169 of file PatternVisualizationTool.h.

m_canvasExtraScale

Gaudi::Property<double> MuonValR4::PatternVisualizationTool::m_canvasExtraScale {this, "CanvasExtraScale" , 1.3}

private

Extra safety margin to zoom out from the Canvas.

Definition at line 175 of file PatternVisualizationTool.h.

m_canvasHeight

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

private

Definition at line 195 of file PatternVisualizationTool.h.

m_canvasLimit

Gaudi::Property<unsigned int> MuonValR4::PatternVisualizationTool::m_canvasLimit {this, "CanvasLimits", 5000}

private

Maximum canvases to draw.

Definition at line 162 of file PatternVisualizationTool.h.

m_canvasPrefix

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

private

Prefix of the individual canvas file names <MANDATORY>

Definition at line 171 of file PatternVisualizationTool.h.

m_canvasWidth

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

private

Definition at line 194 of file PatternVisualizationTool.h.

m_detMgr

const MuonGMR4::MuonDetectorManager* MuonValR4::PatternVisualizationTool::m_detMgr {nullptr}

private

pointer to the Detector manager

Definition at line 201 of file PatternVisualizationTool.h.

m_displayBucket

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_displayBucket {this, "displayBucket", true}

private

Display the surrounding hits from the bucket not part of the seed.

Definition at line 173 of file PatternVisualizationTool.h.

m_displayOnlyTruth

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_displayOnlyTruth {this, "displayTruthOnly", false}

private

Definition at line 197 of file PatternVisualizationTool.h.

m_doEtaBucketViews

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_doEtaBucketViews {this,"doEtaBucketViews", true}

private

Switch to visualize the eta view of the bucket event.

Definition at line 180 of file PatternVisualizationTool.h.

m_doPhiBucketViews

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_doPhiBucketViews {this,"doPhiBucketViews", true}

private

Switch to visualize the phi view of the bucket event.

Definition at line 182 of file PatternVisualizationTool.h.

m_geoCtxKey

SG::ReadHandleKey<ActsGeometryContext> MuonValR4::PatternVisualizationTool::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Geometry context key to retrieve the alignment.

Definition at line 203 of file PatternVisualizationTool.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonValR4::PatternVisualizationTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Service Handle to the IMuonIdHelperSvc.

Definition at line 205 of file PatternVisualizationTool.h.

m_prepContainerKeys

SG::ReadHandleKeyArray<xAOD::UncalibratedMeasurementContainer> MuonValR4::PatternVisualizationTool::m_prepContainerKeys {this, "PrdContainer", {}}

private

Declare dependency on the prep data containers.

Definition at line 184 of file PatternVisualizationTool.h.

m_saveSinglePDFs

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_saveSinglePDFs {this, "saveSinglePDFs", false}

private

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

Definition at line 164 of file PatternVisualizationTool.h.

m_saveSummaryPDF

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::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 167 of file PatternVisualizationTool.h.

m_truthLinkDecorKeys

SG::ReadDecorHandleKeyArray<xAOD::UncalibratedMeasurementContainer> MuonValR4::PatternVisualizationTool::m_truthLinkDecorKeys {this, "LinkDecorKeys", {}}

private

Declaration of the dependency on the decorations.

(Overwritten in initialize)

Definition at line 188 of file PatternVisualizationTool.h.

m_truthLinkDecors

std::vector<SegLinkDecor_t> MuonValR4::PatternVisualizationTool::m_truthLinkDecors {}

private

Definition at line 192 of file PatternVisualizationTool.h.

m_truthSegLinks

Gaudi::Property<std::set<std::string> > MuonValR4::PatternVisualizationTool::m_truthSegLinks {this, "TruthSegDecors", {}}

private

List of truth segment links to fetch.

Definition at line 186 of file PatternVisualizationTool.h.

s_mutex

std::mutex MuonValR4::PatternVisualizationTool::s_mutex {}

staticprivate

Definition at line 207 of file PatternVisualizationTool.h.

---

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

• PatternVisualizationTool.h
• PatternVisualizationTool.cxx