MuonValR4::PatternVisualizationTool Class Reference

#include <PatternVisualizationTool.h>

Inheritance diagram for MuonValR4::PatternVisualizationTool:

Collaboration diagram for MuonValR4::PatternVisualizationTool:

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

Public Member Functions
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 LabeledSegmentSet	getLabeledSegments (const std::vector< const MuonR4::SpacePoint * > &hits) const override final
	Returns whether the hit has been used on the labeled segments we refer to (e.g. More...
virtual LabeledSegmentSet	getLabeledSegments (const std::vector< const xAOD::UncalibratedMeasurement * > &hits) const override final
virtual bool	isLabeled (const MuonR4::SpacePoint &hit) const override final
	Fetches all labeled (e.g. More...
virtual bool	isLabeled (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.2, double startLegY=0.8, const double endLegY=0.3) const
	Writes the chi2 of the hits onto the Canvas. More...
void	drawPrimitives (const TCanvas &can, PrimitiveVec &primitives) const
	Draw the various primitives onto the Canvas. More...
void	paintSimHits (const EventContext &ctx, const xAOD::MuonSegment &truthSeg, PrimitiveVec &primitives, const int view) const
	Paints the truth sim hits associated with the segment. 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.5}
	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...
Gaudi::Property< bool >	m_paintTruthHits {this, "paintTruthHits", false}
	Switch to visualize the truth hits More...
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...
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

LabeledSegmentSet

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

Definition at line 79 of file PatternVisualizationTool.h.

SegLink_t

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

private

Definition at line 213 of file PatternVisualizationTool.h.

SegLinkDecor_t

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

private

Definition at line 215 of file PatternVisualizationTool.h.

SegLinkVec_t

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

private

Definition at line 214 of file PatternVisualizationTool.h.

Member Function Documentation

closeSummaryCanvas()

void MuonValR4::PatternVisualizationTool::closeSummaryCanvas ( ) const

private

Closes the summary canvas & closes the associated ROOT file.

Definition at line 718 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 518 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 = isLabeled(*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 = isLabeled(*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 = isLabeled(*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::MMClusterType: {
                const auto* meas{static_cast<const xAOD::MMCluster*>(underlyingSp->primaryMeasurement())};
                const int boxColor = isLabeled(*meas) ? truthColor : kAquamarine;
                const double boxWidth = 0.5*Gaudi::Units::mm;
                primitives.push_back(drawBox(hit.positionInChamber(), boxWidth, 10.*Gaudi::Units::mm,
                                             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 597 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);
            } 
        }
 
        // adapt the draw range to make sure any detector elements we wish to display 
        // are included 
        for (auto & prim : primitives){
            TBox* theBox = dynamic_cast<TBox*>(prim.get()); 
            if (theBox){
                canvasDim[Edges::zLow] = std::min(canvasDim[Edges::zLow], theBox->GetY1()); 
                canvasDim[Edges::zHigh] = std::max(canvasDim[Edges::zHigh], theBox->GetY2()); 
            }
        }
 
        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;
    }

drawPrimitives()

void MuonValR4::PatternVisualizationTool::drawPrimitives ( const TCanvas &  can, PrimitiveVec &  primitives  ) const

private

Draw the various primitives onto the Canvas.

If a TLine is amongst them it's automatically adjusted to fit the canvas ranges

Parameters

canvas	Reference to the canvas to draw the primitives on
prmitives	Primitives to draw onto the Canvas

Definition at line 135 of file PatternVisualizationTool.cxx.

                                                                                                    {
        const double yLow = can.GetPad(0)->GetUymin();
        const double yHigh = can.GetPad(0)->GetUymax();
        for (auto& prim : primitives) {
            const TObject &primRef = *prim;
            if (typeid(primRef) == typeid(TLine)){
                TLine* line = static_cast<TLine*>(prim.get());
                const Amg::Vector3D linePoint{line->GetX1(), line->GetY1(), 0.};
                const Amg::Vector3D lineDir = Amg::Vector3D{(line->GetX2() - line->GetX1()) / (line->GetY2() - line->GetY1()), 1.,0.}.unit();
                
                const Amg::Vector3D newHigh = linePoint + Amg::intersect<3>(linePoint, lineDir, Amg::Vector3D::UnitY(), yHigh).value_or(0.) * lineDir;
                const Amg::Vector3D newLow = linePoint + Amg::intersect<3>(linePoint, lineDir, Amg::Vector3D::UnitY(), yLow).value_or(0.) * lineDir;
                line->SetX1(newLow.x());
                line->SetY1(newLow.y());
                line->SetX2(newHigh.x());
                line->SetY2(newHigh.y());
            }
            prim->Draw();
        }
 
    }

finalize()

StatusCode MuonValR4::PatternVisualizationTool::finalize ( )

finaloverridevirtual

Definition at line 98 of file PatternVisualizationTool.cxx.

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

getLabeledSegments() [1/2]

LabeledSegmentSet MuonValR4::PatternVisualizationTool::getLabeledSegments ( const std::vector< const MuonR4::SpacePoint * > &  hits ) const

finaloverridevirtual

Returns whether the hit has been used on the labeled segments we refer to (e.g.

truth or data Zµµ)

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 getLabeledSegments(measurements);
    }

getLabeledSegments() [2/2]

LabeledSegmentSet MuonValR4::PatternVisualizationTool::getLabeledSegments ( const std::vector< const xAOD::UncalibratedMeasurement * > &  hits ) const

finaloverridevirtual

Definition at line 124 of file PatternVisualizationTool.cxx.

                                                                                                                                  {
        LabeledSegmentSet 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;
    }

initialize()

StatusCode MuonValR4::PatternVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 56 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);
            }            
            gROOT->SetStyle("ATLAS");
            TStyle* plotStyle = gROOT->GetStyle("ATLAS");
            plotStyle->SetOptTitle(0);
            plotStyle->SetHistLineWidth(1.);
            plotStyle->SetPalette(kViridis);
        }
        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;
    }

isLabeled() [1/2]

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

finaloverridevirtual

Fetches all labeled (e.g.

by truth or Zµµ reco) segments containing at least one measurement in the list passed as arg

Parameters

hit	Reference to the hit to check

Definition at line 102 of file PatternVisualizationTool.cxx.

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

isLabeled() [2/2]

bool MuonValR4::PatternVisualizationTool::isLabeled ( 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 728 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;
    }

paintSimHits()

void MuonValR4::PatternVisualizationTool::paintSimHits ( const EventContext &  ctx, const xAOD::MuonSegment &  truthSeg, PrimitiveVec &  primitives, const int  view  ) const

private

Paints the truth sim hits associated with the segment.

Hits are drawn as orange arrows

Parameters

ctx	EventContext to fetch the alignment constants
truthSeg	Segment made from truth sim hits
primitives	Drawing primitives to append the painted hits
view	Draw the hit either in the eta or phi view

Definition at line 249 of file PatternVisualizationTool.cxx.

                                                                      {
        if (!m_paintTruthHits) {
            return;
        }
        auto truthHits = getMatchingSimHits(truthSeg);
        const ActsGeometryContext* geoCtx{nullptr};
        if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
            return;
        }
        for (const xAOD::MuonSimHit* simHit :  truthHits) {
            const MuonGMR4::MuonReadoutElement* re = m_detMgr->getReadoutElement(simHit->identify());
            const IdentifierHash hash = re->detectorType() == ActsTrk::DetectorType::Mdt ?
                                        re->measurementHash(simHit->identify()) :
                                        re->layerHash(simHit->identify());
            const Amg::Transform3D trf = re->msSector()->globalToLocalTrans(*geoCtx) *
                                         re->localToGlobalTrans(*geoCtx, hash);
            const Amg::Vector3D locPos = trf * xAOD::toEigen(simHit->localPosition());
            const Amg::Vector3D locDir = trf.linear() * xAOD::toEigen(simHit->localDirection());
            primitives.push_back(drawArrow(locPos, locDir, truthColor, kDashed, view));
        }
    }

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 741 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 156 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

TODO: After next ACTS update, the following three lines can become const SpacePointSet& hitsInBin{accumulator.uniqueHitIds(xBin, yBin)};

Definition at line 164 of file PatternVisualizationTool.cxx.

                                                                                         {
 
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        //cppcheck-suppress identicalConditionAfterEarlyExit
        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);
            SpacePointSet hitsInBin;
            auto hitIds = accumulator.hitIds(xBin, yBin); 
            hitsInBin.insert(std::make_move_iterator(hitIds.begin()),std::make_move_iterator(hitIds.end()));
    
            spacePointsInAcc.insert(spacePointsInAcc.end(),hitsInBin.begin(), hitsInBin.end());
            accHisto->SetBinContent(xBin+1, yBin+1, accumulator.nHits(bin));
        }
 
        const LabeledSegmentSet truthSegs{getLabeledSegments(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));
            primitives.push_back(drawLabel(std::format("true parameters: {:}",makeLabel(localSegmentPars(*segment))),0.2, 0.9));
        }
        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));
        }
        primitives.push_back(drawAtlasLabel(0.65, 0.26, m_AtlasLabel));
        primitives.push_back(drawLumiSqrtS(0.65,0.21, m_sqrtSLabel, m_lumiLabel));
        
        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->GetPad(0)->SetRightMargin(0.12);
        canvas->GetPad(0)->SetTopMargin(0.12);
        canvas->cd();
        accHisto->Draw("COLZ");
        drawPrimitives(*canvas, primitives);
        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 351 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 357 of file PatternVisualizationTool.cxx.

                                                                                    {
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        //cppcheck-suppress identicalConditionAfterEarlyExit
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::array<double, 4> canvasDim{};        
        LabeledSegmentSet truthSegs{getLabeledSegments(Acts::unpackConstSmartPointers(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.89));
                    drawnTrueLabel = true;
                }
                paintSimHits(ctx,*segment, primitives, view);
            }
            
            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));
 
            primitives.push_back(drawAtlasLabel(0.75, 0.26, m_AtlasLabel));
            primitives.push_back(drawLumiSqrtS(0.75,0.21, m_sqrtSLabel, m_lumiLabel));
 
            auto can = makeCanvas(ctx , canvasDim, view);
            drawPrimitives(*can, primitives);
 
            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 273 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 279 of file PatternVisualizationTool.cxx.

                                                                                  {
        
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        //cppcheck-suppress identicalConditionAfterEarlyExit
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
 
        const LabeledSegmentSet truthSegs{getLabeledSegments(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));
                paintSimHits(ctx,*segment, primitives, 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())
                       <<std::format(", #chi^{{2}} /nDoF: {:.2f} ({:})", chi2/std::max(1u, nDoF), std::max(1u,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.89));
        
            auto canvas = makeCanvas(ctx, canvasDim, view);
            primitives.push_back(drawAtlasLabel(0.75, 0.26, m_AtlasLabel));
            primitives.push_back(drawLumiSqrtS(0.75,0.21, m_sqrtSLabel, m_lumiLabel));
 
            drawPrimitives(*canvas, primitives);
 
            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 423 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 430 of file PatternVisualizationTool.cxx.

                                                                                     {
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        std::lock_guard guard{s_mutex};
        //cppcheck-suppress identicalConditionAfterEarlyExit
        if (m_canvCounter >= m_canvasLimit) {
            return;
        }
        const LabeledSegmentSet truthSegs{getLabeledSegments(segment.parent()->getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        Parameters segPars{};
        {
            const ActsGeometryContext* geoCtx{nullptr};
            if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
                return;
            }
            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));
                paintSimHits(ctx,*segment, primitives, view);
            }
            writeChi2(segPars, segment.measurements(), primitives);
 
            primitives.push_back(drawAtlasLabel(0.75, 0.26, m_AtlasLabel));
            primitives.push_back(drawLumiSqrtS(0.75,0.21, m_sqrtSLabel, m_lumiLabel));
 
            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)
                        <<std::format(", #chi^{{2}} /nDoF: {:.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.2, 0.96));
            primitives.push_back(drawLabel(makeLabel(segPars),0.25, 0.91));
 
            auto canvas = makeCanvas(ctx, canvasDim, view);
            drawPrimitives(*canvas, primitives);
 
            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.2, 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 644 of file PatternVisualizationTool.cxx.

                                                                             {
        
        const auto [locPos, locDir] = makeLine(pars);
        for (const SpacePointType& hit : hits) { 
            const SpacePoint* underlyingSp{nullptr};
            double chi2{0.};
            bool displayChi2{true};
            if constexpr(std::is_same_v<SpacePointType, Segment::MeasType>) {
                underlyingSp = hit->spacePoint();
                displayChi2 = (hit->fitState() == CalibratedSpacePoint::State::Valid );
                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::string legendstream{};
            switch(hit->type()) {
                case xAOD::UncalibMeasType::MdtDriftCircleType: {
                    const int driftSign{SegmentFitHelpers::driftSign(locPos, locDir, *hit, msgStream())};
                    const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
                    legendstream = std::format("ML: {:1d}, TL: {:1d}, T: {:3d}, {:}",
                                                idHelper.multilayer(hitId), idHelper.tubeLayer(hitId),
                                                idHelper.tube(hitId), driftSign == -1 ? "L" : "R");
                    break;
                } case xAOD::UncalibMeasType::RpcStripType: {
                    const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
                    legendstream= std::format("DR: {:1d}, DZ: {:1d}, GAP: {:1d}, #eta/#phi: {:}/{:}",
                                              idHelper.doubletR(hitId), idHelper.doubletZ(hitId), idHelper.gasGap(hitId),
                                              hit->measuresEta() ? "si" : "nay", hit->measuresPhi() ? "si" : "nay");
                    break;
                } case xAOD::UncalibMeasType::TgcStripType: {
                    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
                    legendstream = std::format("ST: {:}, GAP: {:1d}, #eta/#phi: {:}/{:}",
                                               m_idHelperSvc->stationNameString(hitId), idHelper.gasGap(hitId),
                                               hit->measuresEta() ? "si" : "nay", hit->measuresPhi() ? "si" : "nay");      
                    break;
                } case xAOD::UncalibMeasType::MMClusterType: {
                    const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
                    const auto* clus = static_cast<const xAOD::MMCluster*>(underlyingSp->primaryMeasurement());
                    const MuonGMR4::StripDesign& design = clus->readoutElement()->stripLayer(clus->layerHash()).design();
                    legendstream = std::format("ML: {:1d}, GAP: {:1d}, {:}", idHelper.multilayer(hitId), idHelper.gasGap(hitId),
                                                !design.hasStereoAngle() ? "X"  : design.stereoAngle() > 0 ? "U" :"V");
                    break;
                } case xAOD::UncalibMeasType::sTgcStripType: {
                    const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
                    legendstream = std::format("ML: {:1d}, GAP: {:1d}, #eta/#phi: {:}/{:}", 
                                               idHelper.multilayer(hitId), idHelper.gasGap(hitId),
                                               hit->measuresEta() ? "si" : "nay", hit->measuresPhi() ? "si" : "nay");
                    break;
                }  case xAOD::UncalibMeasType::Other: {
                    legendstream = "Ext. constaint";
                }
                default:
                    break;
            }
            if (displayChi2) {
                legendstream+=std::format(", #chi^{{2}}: {:.2f}", chi2);
            } else {
                legendstream+=", #chi^{2}: ---";
            }
            primitives.push_back(drawLabel(legendstream, 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 232 of file PatternVisualizationTool.h.

ATLAS_THREAD_SAFE [2/3]

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

mutableprivate

Definition at line 233 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 235 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 194 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 185 of file PatternVisualizationTool.h.

m_AtlasLabel

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

private

ATLAS label (Internal / Prelimnary / Simulation)

Definition at line 202 of file PatternVisualizationTool.h.

m_canvasExtraScale

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

private

Extra safety margin to zoom out from the Canvas.

Definition at line 191 of file PatternVisualizationTool.h.

m_canvasHeight

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

private

Definition at line 219 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 178 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 187 of file PatternVisualizationTool.h.

m_canvasWidth

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

private

Definition at line 218 of file PatternVisualizationTool.h.

m_detMgr

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

private

pointer to the Detector manager

Definition at line 225 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 189 of file PatternVisualizationTool.h.

m_displayOnlyTruth

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

private

Definition at line 221 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 196 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 198 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 227 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 229 of file PatternVisualizationTool.h.

m_lumiLabel

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

private

Luminosity label.

Definition at line 206 of file PatternVisualizationTool.h.

m_paintTruthHits

Gaudi::Property<bool> MuonValR4::PatternVisualizationTool::m_paintTruthHits {this, "paintTruthHits", false}

private

Switch to visualize the truth hits

Definition at line 200 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 208 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 180 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 183 of file PatternVisualizationTool.h.

m_sqrtSLabel

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

private

Centre of mass energy label.

Definition at line 204 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 212 of file PatternVisualizationTool.h.

m_truthLinkDecors

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

private

Definition at line 216 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 210 of file PatternVisualizationTool.h.

s_mutex

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

staticprivate

Definition at line 231 of file PatternVisualizationTool.h.

---

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

• PatternVisualizationTool.h
• PatternVisualizationTool.cxx