MuonValR4::FastRecoVisualizationTool Class Reference

#include <FastRecoVisualizationTool.h>

Inheritance diagram for MuonValR4::FastRecoVisualizationTool:

Collaboration diagram for MuonValR4::FastRecoVisualizationTool:

Public Member Functions
virtual StatusCode	initialize () override final
virtual void	plotPatternBuckets (const EventContext &ctx, const std::string &extraLabel, PatternHitVisualInfoVec &&patternVisualVec) const override final
virtual void	plotPatternBuckets (const EventContext &ctx, const std::string &extraLabel, PatternHitVisualInfoVec &&patternVisualVec, PrimitiveVec &&extraPaints) const override final
virtual void	plotPatternBuckets (const EventContext &ctx, const std::string &extraLabel, PatternHitVisualInfo &&patternVisual) const override final
virtual void	plotPatternBuckets (const EventContext &ctx, const std::string &extraLabel, PatternHitVisualInfo &&patternVisual, 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.
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.
virtual bool	isLabeled (const xAOD::UncalibratedMeasurement &hit) const override final
template<class SpacePointType>
const SpacePoint *	drawHit (const SpacePointType &hit, const Amg::Transform3D &localToGlobalBucket, Canvas_t &canvas, const View view, unsigned int fillStyle) const

Private Types
enum class	View { objViewEta = static_cast<int>(MuonValR4::objViewEta) , objViewPhi = static_cast<int>(MuonValR4::objViewPhi) , objViewZR = 2 , objViewRZ = 3 }
	Enum for the different views. More...
using	Canvas_t = IRootVisualizationService::ICanvasObject
using	Edges = Canvas_t::AxisRanges
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	plotPatternBucket (const EventContext &ctx, const std::string &extraLabel, const MuonR4::SpacePointBucket &bucket, PatternHitVisualInfo &&patternVisual, PrimitiveVec &&extraPaints) const
	Plot a single pattern bucket.
void	drawSearchWindow (const Amg::Transform3D &localToGlobalBucket, PrimitiveVec &outputContainer, const double thetaMin, const double thetaMax, const Canvas_t &canvas, const View view) const
	Draw the search window lines in the local frame expressed by the Transform3D for eta views and in the GlobalR-GlobalZ plane for RZ/ZR views.
void	drawLineResidual (const ActsTrk::GeometryContext &gctx, const Amg::Transform3D &localToGlobalBucket, PrimitiveVec &outputContainer, const MuonR4::SpacePoint *seed, const MuonR4::SpacePoint *testHit, const double lineSlope, const double Rwindow, const PatternHitVisualInfo::HitStatus status, const Canvas_t &canvas, const View view) const
	Draw the pattern line and acceptance window for the testHit used during pattern building in the local frame expressed by the Transform3D for eta views and in the GlobalR-GlobalZ plane for RZ/ZR views.
void	drawSegment (const xAOD::MuonSegment &segment, const Amg::Transform3D &localToGlobalBucket, PrimitiveVec &outputContainer, bool &drawnTrueLabel, const Canvas_t &canvas, const View view) const
	Draw a segment on the canvas.
template<class SpacePointType>
bool	drawHits (const MuonR4::SpacePointBucket &bucket, const Amg::Transform3D &localToGlobalBucket, const std::vector< SpacePointType > &hitsToDraw, Canvas_t &canvasDim, const View view) const
	Translates the Spacepoint information into TObjects that are dawn on the canvas & evaluates the size of the box surrounding the event.
template<class SpacePointType>
const MuonR4::SpacePoint *	drawHit (const SpacePointType &hit, const Amg::Transform3D &localToGlobalBucket, Canvas_t &canvas, const View view, unsigned int fillStyle) const
	Converts a Hit into a particular TBox/ TEllipse for drawing.
void	paintSimHits (const ActsTrk::GeometryContext &gctx, const Amg::Transform3D &localToGlobalBucket, const xAOD::MuonSegment &truthSeg, PrimitiveVec &outputContainer, const View view) const
	Paints the truth sim hits associated with the segment.
std::unique_ptr< TLine >	drawLine (const Amg::Vector3D &lineDirection, const Amg::Vector3D &linePoint, const double lowEnd, const double highEnd, const int color=kRed+1, const int lineStyle=kDashed, const View view=View::objViewEta) const
	Draws a line given the parameters of the line in the local frame for Eta and Phi views and in the R-Z plane for RZ (and ZR) views.

Private Attributes
ServiceHandle< IRootVisualizationService >	m_visualSvc {this, "VisualSvc", "MuonValR4::RootVisualizationService"}
	Service handle of the visualization service.
IRootVisualizationService::ClientToken	m_clientToken {}
	Token to present to the visualization service such that the display froms this tool are grouped together.
UnsignedIntegerProperty	m_canvasLimit {this, "CanvasLimits", 5000}
	Maximum canvases to draw.
BooleanProperty	m_saveSinglePDFs {this, "saveSinglePDFs", false}
	If set to true each canvas is saved into a dedicated pdf file.
BooleanProperty	m_saveSummaryPDF {this, "saveSummaryPDF", false}
	If set to true a summary Canvas is created.
StringProperty	m_canvasPrefix {this, "CanvasPreFix", ""}
	Prefix of the individual canvas file names <MANDATORY>
StringProperty	m_subDir {this, "outSubDir", ""}
	Define the subdirectory in which the plots shall be saved.
BooleanProperty	m_doEtaBucketViews {this,"doEtaBucketViews", true}
	Switch to visualize the eta view of the bucket event.
BooleanProperty	m_doPhiBucketViews {this,"doPhiBucketViews", false}
	Switch to visualize the phi view of the bucket event.
BooleanProperty	m_doRZBucketViews {this,"doRZBucketViews", false}
BooleanProperty	m_paintTruthHits {this, "paintTruthHits", false}
	Switch to visualize the truth hits.
BooleanProperty	m_paintTruthSegment {this, "paintTruthSegment", false}
	Switch to visualize the truth segment.
BooleanProperty	m_paintSuccessfullPatterns {this, "PaintSuccessfullPatterns", true, "Toggle the display of successfully built patterns in the visualization"}
	Switch to visualize successfull patterns.
BooleanProperty	m_paintFailedPatterns {this, "PaintFailedPatterns", false, "Toggle the display of failed patterns in the visualization"}
	Switch to visualize failed patterns.
BooleanProperty	m_paintOverlapPatterns {this, "PaintOverlapPatterns", false, "Toggle the display of overlap patterns in the visualization"}
	Switch to visualize overlap patterns.
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer >	m_prepContainerKeys {this, "PrdContainer", {}}
	Declare dependency on the prep data containers.
Gaudi::Property< std::set< std::string > >	m_truthSegLinks {this, "TruthSegDecors", {}}
	List of truth segment links to fetch.
SG::ReadDecorHandleKeyArray< xAOD::UncalibratedMeasurementContainer >	m_truthLinkDecorKeys {this, "LinkDecorKeys", {}}
	Declaration of the dependency on the decorations.
std::vector< SegLinkDecor_t >	m_truthLinkDecors {}
BooleanProperty	m_displayOnlyTruth {this, "displayTruthOnly", false}
	Toggle to print pattern buckets only if they contain truth hits.
BooleanProperty	m_displayOnlyWithPattern {this, "displayOnlyWithPattern", true}
	Toggle to print pattern buckets only if they contain pattern hits.
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	pointer to the Detector manager
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Geometry context key to retrieve the alignment.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Service Handle to the IMuonIdHelperSvc.
std::atomic< bool > m_plotsDone	ATLAS_THREAD_SAFE {false}
	Flag toggling whether all Canvases have been exhausted.

Detailed Description

Definition at line 28 of file FastRecoVisualizationTool.h.

Member Typedef Documentation

Canvas_t

using MuonValR4::FastRecoVisualizationTool::Canvas_t = IRootVisualizationService::ICanvasObject

private

Definition at line 66 of file FastRecoVisualizationTool.h.

Edges

using MuonValR4::FastRecoVisualizationTool::Edges = Canvas_t::AxisRanges

private

Definition at line 67 of file FastRecoVisualizationTool.h.

SegLink_t

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

private

Definition at line 230 of file FastRecoVisualizationTool.h.

SegLinkDecor_t

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

private

Definition at line 232 of file FastRecoVisualizationTool.h.

SegLinkVec_t

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

private

Definition at line 231 of file FastRecoVisualizationTool.h.

Member Enumeration Documentation

View

enum class MuonValR4::FastRecoVisualizationTool::View

strongprivate

Enum for the different views.

Enumerator
objViewEta
objViewPhi
objViewZR
objViewRZ

Definition at line 60 of file FastRecoVisualizationTool.h.

                            {
                objViewEta = static_cast<int>(MuonValR4::objViewEta),
                objViewPhi = static_cast<int>(MuonValR4::objViewPhi),
                objViewZR = 2,
                objViewRZ = 3
            };

Member Function Documentation

drawHit() [1/2]

template<class SpacePointType>

const SpacePoint * MuonValR4::FastRecoVisualizationTool::drawHit	(	const SpacePointType &	hit,
		const Amg::Transform3D &	localToGlobalBucket,
		Canvas_t &	canvas,
		const View	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 475 of file FastRecoVisualizationTool.cxx.

                                                                             {
        
        const bool isEtaView {view == View::objViewEta || view == View::objViewRZ || view == View::objViewZR};
        if ((isEtaView && !hit.measuresEta()) || (view == View::objViewPhi && !hit.measuresPhi())) {
            return nullptr;
        }
        const Amg::Vector3D& localPos {hit.localPosition()};
        const Amg::Vector3D globalPos {localToGlobalBucket * localPos};
        const auto expand = [&canvas, &hit]( double centerX, double centerY) {
            canvas.expandPad(centerX- hit.driftRadius(), centerY - hit.driftRadius());
            canvas.expandPad(centerX+ hit.driftRadius(), centerY + hit.driftRadius());
        };
        if (hit.type() != xAOD::UncalibMeasType::Other) {
            if (view == View::objViewEta || view == View::objViewPhi) {
                expand(localPos[static_cast<int>(view)], localPos.z());
            } else if (view == View::objViewZR) {
                expand(globalPos.z(), globalPos.perp());
            } else if (view == View::objViewRZ) {
                expand(globalPos.perp(), globalPos.z());
            }
        }
        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;
            }
        }
        const Amg::Vector3D posInCanvas = [view, localPos, globalPos]() -> Amg::Vector3D{
            switch (view) {
                case View::objViewEta:
                case View::objViewPhi:
                    return localPos;
                case View::objViewZR:
                    return globalPos.z()* Amg::Vector3D::UnitY() + globalPos.perp() * Amg::Vector3D::UnitZ();
                case View::objViewRZ:
                    return globalPos.z()* Amg::Vector3D::UnitZ() + globalPos.perp() * Amg::Vector3D::UnitY();
            }
            return Amg::Vector3D::Zero();
        }();
        const int covIdx {view == View::objViewPhi ? static_cast<int>(View::objViewPhi) : static_cast<int>(View::objViewEta)};
        switch(hit.type()) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(underlyingSp->primaryMeasurement());
                canvas.add(drawDriftCircle(posInCanvas, dc->readoutElement()->innerTubeRadius(), 
                                                     kBlack, hollowFilling));
 
                const int circColor = isLabeled(*dc) ? truthColor : kBlue;                    
                canvas.add(drawDriftCircle(posInCanvas, 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)*std::sqrt(underlyingSp->covariance()[covIdx]);
                canvas.add(drawBox(posInCanvas, boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   boxColor, fillStyle, covIdx));
                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)*std::sqrt(underlyingSp->covariance()[covIdx]);
                canvas.add(drawBox(posInCanvas, boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   boxColor, fillStyle, covIdx));
                break; 
            } case xAOD::UncalibMeasType::MMClusterType: {
                const int boxColor = isLabeled(*underlyingSp->primaryMeasurement()) ? truthColor : kAquamarine;
                const double boxWidth = 5*Gaudi::Units::mm;
                canvas.add(drawBox(posInCanvas, boxWidth, 10.*Gaudi::Units::mm, boxColor, fillStyle, covIdx));
                break; 
            }  case xAOD::UncalibMeasType::Other: {
                break;
            }  case xAOD::UncalibMeasType::sTgcStripType: {
                const int boxColor = isLabeled(*underlyingSp->primaryMeasurement()) ? truthColor : kTeal;
                const double boxWidth = 5*Gaudi::Units::mm;
                canvas.add(drawBox(posInCanvas, boxWidth, 10.*Gaudi::Units::mm, boxColor, fillStyle, covIdx));
                break;
            } default: {
                ATH_MSG_WARNING("Please implement proper drawings of the new small wheel.. "<<__FILE__<<":"<<__LINE__);    
                break;
            }
        }
        return underlyingSp;
    }

drawHit() [2/2]

template<class SpacePointType>

const MuonR4::SpacePoint * MuonValR4::FastRecoVisualizationTool::drawHit ( const SpacePointType & hit, const Amg::Transform3D & localToGlobalBucket, Canvas_t & canvas, const View 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
localToGlobalBucket	Bucket frame transformation, used for the conversion of the line parameters from global to local frame and viversa
canvas	Reference to the Canvas object to which the drawn hits are appended. The drawn hits also expand the drawn range
view	Draw the hit either in the eta or phi view,
fillStyle	Standard fill style for the box e.g. full.

drawHits()

template<class SpacePointType>

bool MuonValR4::FastRecoVisualizationTool::drawHits ( const MuonR4::SpacePointBucket & bucket, const Amg::Transform3D & localToGlobalBucket, const std::vector< SpacePointType > & hitsToDraw, Canvas_t & canvasDim, const View 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
localToGlobalBucket	Bucket frame transformation, used for the conversion of the line parameters from global to local frame and viversa
hitsToDraw	Primary hit collection to draw which are drawn with fullFillStyle
canvas	Reference to the Canvas object to which the drawn hits are appended. The drawn hits also expand the drawn range
view	Either the eta or the phi view?

Definition at line 579 of file FastRecoVisualizationTool.cxx.

                                                                        {
 
        SpacePointSet drawnPoints{};
        for (const SpacePointType& hit : hitsToDraw) {            
            drawnPoints.insert(drawHit(*hit, localToGlobalBucket, canvas, view, fullFilling));
        }
        for (const SpacePointBucket::value_type& hit : bucket) {
            // Don't redraw the other points
            if (drawnPoints.count(hit.get())) {
                continue;
            }
            drawHit(*hit, localToGlobalBucket, canvas, view, hollowFilling);
        }
        return drawnPoints.size() - drawnPoints.count(nullptr) > 1;
    }

drawLine()

std::unique_ptr< TLine > MuonValR4::FastRecoVisualizationTool::drawLine ( const Amg::Vector3D & lineDirection, const Amg::Vector3D & linePoint, const double lowEnd, const double highEnd, const int color = kRed +1, const int lineStyle = kDashed, const View view = View::objViewEta ) const

private

Draws a line given the parameters of the line in the local frame for Eta and Phi views and in the R-Z plane for RZ (and ZR) views.

Parameters

lineDirection	Line direction vector in the local frame for Eta and Phi views or in the z-y plane (convention) for RZ and ZR views
linePoint	Point on the line in the local frame for Eta and Phi views or in the z-y plane (convention) for RZ and ZR views
lowEnd	Lower boundary in Canvas-y of the line (i.e. loc Z) for Eta/Phi views, or in global R for ZR/RZ views. If the line is perpendicular to the Canvas-y/globalR axis, it will be interpreted as Canvas-x/globalZ lower limit.
highEnd	Upper boundary in Canvas-y of the line, (i.e. loc Z) for Eta/Phi views, or in global R for ZR/RZ views. If the line is perpendicular to the Canvas-y/globalR axis, it will be interpreted as Canvas-x/globalZ upper limit.
lineStyle	Style of the drawn line (cf. TAttLine documentation)
view	Is the line placed in the y-z or x-z plane or R-Z/Z-R planes

For eta and phi views, we work in the local frame

In the case of a line parallel to the loc Y axis (i.e. horizontal in the Canvas)

For R-Z and Z-R views, we work in the global frame, and the limits are on R. By convention, we use the Z-y plane in 3D space to store the line parameters

Special case: line parallel to global Z axis (constant in global R)

Z along the x-axis of the canvas, R along the y-axis

R along the x-axis, Z along the y-axis

Special case: line parallel to global R axis

Z along the x-axis of the canvas, R along the y-axis

R along the x-axis, Z along the y-axis

Z along the x-axis of the canvas, R along the y-axis

R along the x-axis, Z along the y-axis

Definition at line 598 of file FastRecoVisualizationTool.cxx.

                                                                                      {
        using Parameters = MuonR4::SegmentFit::Parameters;
        using ParamDefs = MuonR4::SpacePoint::SeedingAux::FitParIndex;
        auto makeLine = [](const double x1, const double y1, const double x2, const double y2, const int color, const int style){
            auto line = std::make_unique<TLine>(x1, y1, x2, y2);
            line->SetLineColor(color);
            line->SetLineWidth(2);
            line->SetLineStyle(style);
            return line;
        };
        
        if (view == View::objViewEta || view == View::objViewPhi){
            if (std::abs(lineDirection.z()) < std::numeric_limits<double>::epsilon()) {
                return makeLine(lowEnd, linePoint.z(), highEnd, linePoint.z(), color, lineStyle);
            } else {
                return MuonValR4::drawLine(linePoint + Amg::intersect<3>(linePoint,lineDirection,Amg::Vector3D::UnitZ(), lowEnd).value_or(0.)* lineDirection,
                                    linePoint + Amg::intersect<3>(linePoint,lineDirection,Amg::Vector3D::UnitZ(), highEnd).value_or(0.)* lineDirection,
                                    color, lineStyle, static_cast<int>(view));
            }
        } else {
            if (std::abs(lineDirection.y()) < std::numeric_limits<double>::epsilon()) {
                if (view == View::objViewZR) {
                    return makeLine(lowEnd, linePoint.y(), highEnd, linePoint.y(), color, lineStyle);
                } else {
                    return makeLine(linePoint.y(), lowEnd, linePoint.y(), highEnd, color, lineStyle);
                }
            } else if (std::abs(lineDirection.z()) < std::numeric_limits<double>::epsilon()) {
                if (view == View::objViewZR) {
                    return makeLine(linePoint.z(), lowEnd, linePoint.z(), highEnd, color, lineStyle);
                } else {
                    return makeLine(lowEnd, linePoint.z(), highEnd, linePoint.z(), color, lineStyle);
                }
            } else {
                const double slope {lineDirection.y() / lineDirection.z()};
                const double intercept {linePoint.y() - slope * linePoint.z()};
                const double Zlow {(lowEnd - intercept) / slope};
                const double Zhigh {(highEnd - intercept) / slope};
                if (view == View::objViewZR) {
                    return makeLine(Zlow, lowEnd, Zhigh, highEnd, color, lineStyle);
                } else {
                    return makeLine(lowEnd, Zlow, highEnd, Zhigh, color, lineStyle);
                }
            }
        }
    }

drawLineResidual()

void MuonValR4::FastRecoVisualizationTool::drawLineResidual ( const ActsTrk::GeometryContext & gctx, const Amg::Transform3D & localToGlobalBucket, PrimitiveVec & outputContainer, const MuonR4::SpacePoint * seed, const MuonR4::SpacePoint * testHit, const double lineSlope, const double Rwindow, const PatternHitVisualInfo::HitStatus status, const Canvas_t & canvas, const View view ) const

private

Draw the pattern line and acceptance window for the testHit used during pattern building in the local frame expressed by the Transform3D for eta views and in the GlobalR-GlobalZ plane for RZ/ZR views.

Parameters

gctx	Geometry context needed to retrieve the seed global position and its position in the bucket frame
localToGlobalBucket	Bucket frame transformation, used for the conversion of the line parameters from global to local frame and viversa
outputContainer	Vector to which the drawn lines are appended
seed	Seed hit of the pattern
testHit	Hit being tested during pattern building
lineSlope	Slope of the pattern line in the GlobalR-GlobalZ plane computed during pattern building to test the testHit
Rwindow	Size of the acceptance window in the GlobalR direction to accept the testHit in pattern building
status	Status of the testHit during pattern building (e.g. accepted, rejected or replaced)
canvas	Reference to the Canvas object to which the drawn lines. Needed to set the line limits
view	Draw the line in the eta or RZ/ZR view

In phi view we dont plot anything

We do not expect pattern lines horizontal in global Z vs global R plane

Draw the pattern line in the z-y plane of the 3D space (convention)

Determine the extremes of that line

Draw the acceptance lines in R

Draw the pattern line in the local frame of the testHit. Using the chamber phi we ensure the line is always in the y-z plane

Retrieve the seed position in the local frame of the bucket we want to draw

Determine the extremes of that line

Draw the acceptance lines in R

Definition at line 316 of file FastRecoVisualizationTool.cxx.

                                                                            {
        using HitStatus = PatternHitVisualInfo::HitStatus;
        if (view == View::objViewPhi) {
            return;
        }
        if (std::abs(lineSlope) < std::numeric_limits<double>::epsilon()) {
            return;
        }
        auto color {status == HitStatus::eKept ? kGreen : (status == HitStatus::eReplaced ? kPink : kGray)};
        if (view == View::objViewZR || view == View::objViewRZ) {
            const Amg::Vector3D lineDir {Acts::makeDirectionFromAxisTangents(0., lineSlope)};
            const Amg::Vector3D seedGlobalPos {seed->msSector()->localToGlobalTransform(gctx) * seed->localPosition()};
            const Amg::Vector3D linePos {seedGlobalPos.perp()* Amg::Vector3D::UnitY() + seedGlobalPos.z() * Amg::Vector3D::UnitZ()};
            const double seedGlobalR {seedGlobalPos.perp()};
            const double testGlobalR {(localToGlobalBucket * testHit->localPosition()).perp()};
            const double testGlobalZ {(localToGlobalBucket * testHit->localPosition()).z()};
            const double lineIntercept {linePos.y() - lineSlope * linePos.z()};
            const double line2WindowInters {lineSlope*testGlobalZ + lineIntercept};
            double lowLimit{};
            double upLimit{};
            if (seedGlobalR < testGlobalR) {
                lowLimit = (seed->msSector() == testHit->msSector() ? 
                        seedGlobalR : (view == View::objViewZR ? canvas.corner(Edges::yLow) : canvas.corner(Edges::xLow)));
                upLimit = line2WindowInters;
            } else {
                upLimit = (seed->msSector() == testHit->msSector() ? 
                        seedGlobalR : (view == View::objViewZR ? canvas.corner(Edges::yHigh) : canvas.corner(Edges::xHigh)));
                lowLimit = line2WindowInters;
            }
            outputContainer.emplace_back(drawLine(lineDir, linePos, 
                    lowLimit, upLimit, color, kDashed, view));

            const Amg::Vector3D barLineDir {Amg::Vector3D::UnitY()};
            const Amg::Vector3D barLinePos {testGlobalZ* Amg::Vector3D::UnitZ()};
            lowLimit = testGlobalR - Rwindow;
            upLimit = testGlobalR + Rwindow;
            outputContainer.emplace_back(drawLine(barLineDir, barLinePos, 
                    lowLimit, upLimit, color, kDotted, view));
        } else {
            const double globLineTheta { lineSlope > 0 ? atan(lineSlope) : atan(lineSlope) + M_PI };
            const double globLinePhi {localToGlobalBucket.translation().phi()};
            const Amg::Vector3D globLineDir {Acts::makeDirectionFromPhiTheta(globLinePhi,globLineTheta)};
            const Amg::Vector3D locLineDir {localToGlobalBucket.inverse().linear() * globLineDir};
            const Amg::Vector3D seedGlobalPos {seed->msSector()->localToGlobalTransform(gctx) * seed->localPosition()};
            const Amg::Vector3D seedLocalPos {localToGlobalBucket.inverse() * seedGlobalPos};
            const double& testLocalZ {testHit->localPosition().z()};   
            const double& testLocalY {testHit->localPosition().y()};   
            const double testGlobalR {(localToGlobalBucket * testHit->localPosition()).perp()};
            double seedGlobalR {seedGlobalPos.perp()};
            const bool isBarrel {seed->msSector()->barrel()};
            const double line2WindowInters {isBarrel ? Acts::detail::LineHelper::lineIntersect<3>(seedLocalPos, locLineDir, testLocalY* Amg::Vector3D::UnitY(), Amg::Vector3D::UnitZ()).position().z()
                                                     : Acts::detail::LineHelper::lineIntersect<3>(seedLocalPos, locLineDir, testLocalZ* Amg::Vector3D::UnitZ(), Amg::Vector3D::UnitY()).position().z()};
            double lowLimit{};
            double upLimit{};
            if (seedGlobalR < testGlobalR) {
                lowLimit = (seed->msSector() == testHit->msSector() ? seedLocalPos.z() : canvas.corner(Edges::yLow));
                upLimit = line2WindowInters;
            } else {
                upLimit = (seed->msSector() == testHit->msSector() ? seedLocalPos.z() : canvas.corner(Edges::yHigh));
                lowLimit = line2WindowInters;
            }
            outputContainer.emplace_back(drawLine(locLineDir, seedLocalPos, 
                    lowLimit, upLimit, color, kDashed, view));

            const Amg::Vector3D barLineDir {isBarrel ? Amg::Vector3D::UnitZ() : Amg::Vector3D::UnitY()};
            const Amg::Vector3D barLinePos {isBarrel ? testLocalY* Amg::Vector3D::UnitY() : testLocalZ* Amg::Vector3D::UnitZ()};
            lowLimit = isBarrel ? testLocalZ - Rwindow : testLocalY - Rwindow;
            upLimit = isBarrel ? testLocalZ + Rwindow : testLocalY + Rwindow;
            outputContainer.emplace_back(drawLine(barLineDir, barLinePos, 
                    lowLimit, upLimit, color, kDotted, view));
        }
    }

drawSearchWindow()

void MuonValR4::FastRecoVisualizationTool::drawSearchWindow ( const Amg::Transform3D & localToGlobalBucket, PrimitiveVec & outputContainer, const double thetaMin, const double thetaMax, const Canvas_t & canvas, const View view ) const

private

Draw the search window lines in the local frame expressed by the Transform3D for eta views and in the GlobalR-GlobalZ plane for RZ/ZR views.

Parameters

localToGlobalBucket	Bucket frame transformation, used for the conversion of the line parameters from global to local frame and viversa
outputContainer	Vector to which the drawn lines are appended
thetaMin	Minimum global theta of the search window
thetaMax	Maximum global theta of the search window
canvas	Reference to the Canvas object to which the drawn lines. Needed to set the line limits
view	Draw the line in the eta or RZ/ZR view

In phi view we dont plot anything

We do not expect pattern lines horizontal in global Z vs global R plane

In RZ views, we have already the slope. We draw the line in the z-y plane of the 3D space (convention)

In eta views, we need to convert the slope from global to local frame

Definition at line 274 of file FastRecoVisualizationTool.cxx.

                                                                            {
        if (view == View::objViewPhi) {
            return;
        }
        auto addSearchWindowLine = [&outputContainer, &localToGlobalBucket, &view, &canvas, this](const double globLineTheta){
            constexpr double smallAngle {1e-3};
            if (std::abs(globLineTheta) < smallAngle || std::abs(globLineTheta - M_PI) < smallAngle) {
                throw std::runtime_error("Unexpected horizontal pattern search line in global frame. Cannot draw search window.");
                return;
            }
            Amg::Vector3D lineDirection{};
            Amg::Vector3D linePosition{};    
            double lowEnd{};
            double upEnd{};
            if (view == View::objViewZR || view == View::objViewRZ) {
                lineDirection = Acts::makeDirectionFromAxisTangents(0., tan(globLineTheta));
                linePosition = Amg::Vector3D::Zero();
                lowEnd = view == View::objViewZR ? canvas.corner(Edges::yLow) : canvas.corner(Edges::xLow);
                upEnd = view == View::objViewZR ? canvas.corner(Edges::yHigh) : canvas.corner(Edges::xHigh);
            } else {
                const double globLinePhi {localToGlobalBucket.translation().phi()};
                const Amg::Vector3D globLineDir {Acts::makeDirectionFromPhiTheta(globLinePhi,globLineTheta)};
                lineDirection = localToGlobalBucket.inverse().linear() * globLineDir;
                linePosition = localToGlobalBucket.inverse() * Amg::Vector3D::Zero();
                lowEnd = canvas.corner(Edges::yLow);
                upEnd = canvas.corner(Edges::yHigh);
            }
            outputContainer.emplace_back(drawLine(lineDirection, linePosition, 
                    lowEnd, upEnd, kOrange, kDashed, view));
        };
        addSearchWindowLine(thetaMin);
        addSearchWindowLine(thetaMax);                                        
    }

drawSegment()

void MuonValR4::FastRecoVisualizationTool::drawSegment ( const xAOD::MuonSegment & segment, const Amg::Transform3D & localToGlobalBucket, PrimitiveVec & outputContainer, bool & drawnTrueLabel, const Canvas_t & canvas, const View view ) const

private

Draw a segment on the canvas.

Parameters

segment	Segment to draw
localToGlobalBucket	Bucket frame transformation, used for the conversion of the line parameters from global to local frame and viversa
outputContainer	Vector to which the drawn lines are appended
drawnTrueLabel	Boolean set to true if the label with the true segment parameters has already been drawn on the canvas. If not, it is drawn with the segment and the boolean is set to true.
canvas	Reference to the Canvas object to which the drawn lines. Needed to set the line limits
view	Draw the line in the eta or RZ/ZR view

Compute line and direction in the global frame

Compute line and direction in the globalR-GlobalZ plane

Definition at line 406 of file FastRecoVisualizationTool.cxx.

                                                                       {
        if (!m_paintTruthSegment){
            return;
        }
        auto [linePos, lineDir] = makeLine(localSegmentPars(segment));
        double lowEnd{canvas.corner(Edges::yLow)};
        double highEnd{canvas.corner(Edges::yHigh)};
        if (view == View::objViewZR || view == View::objViewRZ){
            const Amg::Vector3D globDir {localToGlobalBucket.linear() * lineDir};
            const Amg::Vector3D globPos {localToGlobalBucket * linePos};
            const double slopeRZ {(globPos.x()*globDir.x() + globPos.y()*globDir.y()) / (globPos.perp()*globDir.z())};
            lineDir = Acts::makeDirectionFromAxisTangents(0., slopeRZ);
            linePos = globPos.perp()* Amg::Vector3D::UnitY() + globPos.z() * Amg::Vector3D::UnitZ();
            if (view == View::objViewRZ) {
                lowEnd = canvas.corner(Edges::xLow);
                highEnd = canvas.corner(Edges::xHigh);
            }
        }
        outputContainer.emplace_back(drawLine(lineDir, linePos, lowEnd, highEnd,
                                    truthColor, kDotted, view));
        if (!drawnTrueLabel) {
            outputContainer.emplace_back(drawLabel(std::format("true parameters: {:}",makeLabel(localSegmentPars(segment))),0.2, 0.89));
            drawnTrueLabel = true;
        }
    }

getLabeledSegments() [1/2]

FastRecoVisualizationTool::LabeledSegmentSet MuonValR4::FastRecoVisualizationTool::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 84 of file FastRecoVisualizationTool.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]

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

finaloverridevirtual

Definition at line 95 of file FastRecoVisualizationTool.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::FastRecoVisualizationTool::initialize ( )

finaloverridevirtual

Definition at line 32 of file FastRecoVisualizationTool.cxx.

                                                    {      
        if (m_canvasLimit > 0) {
            m_clientToken.canvasLimit = m_canvasLimit;
            m_clientToken.preFixName = m_canvasPrefix;
            m_clientToken.saveSinglePlots = m_saveSinglePDFs;
            m_clientToken.saveSummaryPlot = m_saveSummaryPDF;
            m_clientToken.subDirectory = m_subDir;
            ATH_CHECK(m_visualSvc.retrieve());
            ATH_CHECK(m_visualSvc->registerClient(m_clientToken));
        } else {
            m_plotsDone = true;
        }
        ATH_CHECK(m_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));
        if (!m_doEtaBucketViews && !m_doPhiBucketViews && !m_doRZBucketViews) {
            ATH_MSG_ERROR("No bucket view enabled. Please enable at least one of the bucket views to visualize the buckets.");
            return StatusCode::FAILURE;
        }
        if(int(m_doEtaBucketViews) + int(m_doPhiBucketViews) + int(m_doRZBucketViews) > 1) {
            ATH_MSG_ERROR("Multiple bucket views enabled. Please enable only one bucket view.");
            return StatusCode::FAILURE;
        }
        return StatusCode::SUCCESS;
    }

isLabeled() [1/2]

bool MuonValR4::FastRecoVisualizationTool::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 74 of file FastRecoVisualizationTool.cxx.

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

isLabeled() [2/2]

bool MuonValR4::FastRecoVisualizationTool::isLabeled ( const xAOD::UncalibratedMeasurement & hit ) const

finaloverridevirtual

Definition at line 78 of file FastRecoVisualizationTool.cxx.

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

paintSimHits()

void MuonValR4::FastRecoVisualizationTool::paintSimHits ( const ActsTrk::GeometryContext & gctx, const Amg::Transform3D & localToGlobalBucket, const xAOD::MuonSegment & truthSeg, PrimitiveVec & outputContainer, const View view ) const

private

Paints the truth sim hits associated with the segment.

Hits are drawn as orange arrows

Parameters

gctx	Geometry context to fetch the alignment constants
truthSeg	Segment made from truth sim hits
outputContainer	Vector to which the drawn lines are appended
view	Draw the hit either in the eta or phi view

Compute line and direction in the global frame

Definition at line 438 of file FastRecoVisualizationTool.cxx.

                                                                        {
        if (!m_paintTruthHits) {
            return;
        }
        auto truthHits = getMatchingSimHits(truthSeg);
        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()->globalToLocalTransform(gctx) *
                                         re->localToGlobalTransform(gctx, hash);
            const Amg::Vector3D locPos = trf * xAOD::toEigen(simHit->localPosition());
            const Amg::Vector3D locDir = trf.linear() * xAOD::toEigen(simHit->localDirection());
            if (view == View::objViewEta || view == View::objViewPhi){
                outputContainer.emplace_back(drawArrow(locPos, locDir, truthColor, kDashed, static_cast<int>(view)));
            } else {
                constexpr double arrowLength = 2.*Gaudi::Units::cm; 
                const Amg::Vector3D globDir {localToGlobalBucket.linear() * locDir};
                const Amg::Vector3D globPos {localToGlobalBucket * locPos};
                const Amg::Vector3D end = globPos + (arrowLength / std::hypot(globDir.z(),globDir.perp()) ) * globDir;
                auto arrow = view == View::objViewZR ? std::make_unique<TArrow>(globPos.z(), globPos.perp(), end.z(), end.perp(),0.01) :
                                                       std::make_unique<TArrow>(globPos.perp(), globPos.z(), end.perp(), end.z(),0.01);
                arrow->SetLineColor(truthColor);
                arrow->SetLineWidth(2);
                arrow->SetLineStyle(kDashed);
                outputContainer.emplace_back(std::move(arrow));
            }
        }
    }

plotPatternBucket()

void MuonValR4::FastRecoVisualizationTool::plotPatternBucket ( const EventContext & ctx, const std::string & extraLabel, const MuonR4::SpacePointBucket & bucket, PatternHitVisualInfo && patternVisual, PrimitiveVec && extraPaints ) const

private

Plot a single pattern bucket.

Parameters

ctx	Event Context
extraLabel	Extra label for the plot
bucket	Reference to the pattern bucket to plot
patternVisual	Visual information for the pattern
extraPaints	Additional painting instructions

Check whether the canvas limit has been reached

Check whether to display only patterns with truth information

Check whether the pattern status is to be displayed

Check whether to display only buckets with patterns. Collect pattern hits belonging to the bucket and check the size

Prepare the canvas for drawing

Determine the view to use ad, in cae=se of Z-R view, check if we have two swap the axis (e.g. endcap)

Check the orientatation of the local y axis. If is not aligned to the global Z, we will swap the axis for RZ views

First draw the pattern hits in this bucket

Draw the search window

Print first all the lines

Check if we have the bucket hit in this pattern visual

Check if the hit has been replaced or removed

Print pattern and acceptance window lines corresponding to this bucket hit

Print pattern information on the canvas

Draw truth segments

Definition at line 143 of file FastRecoVisualizationTool.cxx.

                                                                                        {
        using PatternStatus = FastRecoVisualizationTool::PatternHitVisualInfo::PatternStatus;
        using HitStatus = FastRecoVisualizationTool::PatternHitVisualInfo::HitStatus;
        if (m_plotsDone) {
            return;
        }
        LabeledSegmentSet truthSegs{getLabeledSegments(Acts::unpackConstSmartPointers(bucket))};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        PatternStatus patStatus{patternVisual.status};
        if ((patStatus == PatternStatus::eSuccessful && !m_paintSuccessfullPatterns) || 
            (patStatus == PatternStatus::eFailed && !m_paintFailedPatterns) || 
            (patStatus == PatternStatus::eOverlap && !m_paintOverlapPatterns)) {
            return;
        }
        std::vector<const MuonR4::SpacePoint*> patHitsInBucket{};
        const MuonR4::GlobalPattern& pat {*patternVisual.patternCopy};
        for (const Muon::MuonStationIndex::StIndex& station : pat.getStations()) {
            for (const MuonR4::SpacePoint* hit : pat.hitsInStation(station)) {   
                if (std::ranges::find_if(bucket, 
                        [hit](const std::shared_ptr<MuonR4::SpacePoint> sp) { return sp.get() == hit; }) != bucket.end()) {
                    patHitsInBucket.push_back(hit);      
                }
            }
        }     
        if (patHitsInBucket.empty() && m_displayOnlyWithPattern) {
            return;
        }
        std::string nameTag = std::format("{}_{}_Bkt_{:d}", extraLabel, bucket.msSector()->identString(), bucket.bucketId());
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, nameTag);
        if (!canvas){
            m_plotsDone = true;
            return;
        }
        canvas->add(std::move(extraPaints));
        const ActsTrk::GeometryContext* geoCtx{nullptr};
        if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
            throw std::runtime_error("Failed to retrieve GeometryContext from EventStore");
            return;
        }
        View view{m_doEtaBucketViews ? View::objViewEta : (m_doPhiBucketViews ? View::objViewPhi : View::objViewZR)};
        const Amg::Transform3D& localToGlobalBucket{bucket.msSector()->localToGlobalTransform(*geoCtx)};
        if (view == View::objViewZR && !bucket.msSector()->barrel()) {
            view = View::objViewRZ;                        
        }
        switch (view) {
            case View::objViewEta:
                canvas->setAxisTitles("y [mm]", "z [mm]");
                break;
            case View::objViewPhi:
                canvas->setAxisTitles("x [mm]", "z [mm]");
                break;
            case View::objViewZR:
                canvas->setAxisTitles("z [mm]", "R [mm]");
                break;
            case View::objViewRZ:
                canvas->setAxisTitles("R [mm]", "z [mm]");
                break;
        }
        if (!drawHits(bucket, localToGlobalBucket, patHitsInBucket, *canvas, view)) {
            return;
        }
 
        PrimitiveVec lines{};

        drawSearchWindow(localToGlobalBucket, lines, patternVisual.thetaSearchMin, patternVisual.thetaSearchMax, *canvas, view);
            
        for (const auto& sp : bucket) {
            const MuonR4::SpacePoint* testHit {sp.get()};
            if (patternVisual.hitLineInfo.find(testHit) == patternVisual.hitLineInfo.end()) {
                continue;
            }
            const HitStatus hitStatus {std::ranges::find(patternVisual.discardedHits, testHit) != patternVisual.discardedHits.end() ? HitStatus::eDiscarded : 
                                      (std::ranges::find(patternVisual.replacedHits, testHit) != patternVisual.replacedHits.end() ? HitStatus::eReplaced : HitStatus::eKept)};
                
            const auto& [lineSlope, deltaRWindow] = patternVisual.hitLineInfo.at(testHit);
            drawLineResidual(*geoCtx, localToGlobalBucket, lines, patternVisual.seed, testHit, lineSlope, deltaRWindow, hitStatus, *canvas, view);
        }

        double yLegend{0.9};
        auto printOnCanvas = [&lines, &yLegend](const std::string& text){
            lines.push_back(drawLabel(text, 0.2, yLegend, 13));
            yLegend-=0.03;
        };
        
        printOnCanvas(std::format("Seed hit: {}", m_idHelperSvc->toString(patternVisual.seed->identify())));
        printOnCanvas(std::format("Chamber: {}", m_idHelperSvc->toStringChamber(bucket.front()->identify())));
        printOnCanvas(std::format("nPrec: {:d}", pat.nPrecisionHits()));
        printOnCanvas(std::format("nEtaNonPrec: {:d}", pat.nEtaNonPrecisionHits()));
        printOnCanvas(std::format("nPhi: {:d}", pat.nPhiHits()));
        printOnCanvas(std::format("theta: {:.2f}^{{#circ}}", inDegrees(pat.theta())));
        printOnCanvas(std::format("phi: {:.2f}^{{#circ}}", inDegrees(pat.phi())));
        printOnCanvas(std::format("TotalResidual: {:.2f}", pat.totalResidual()));
        printOnCanvas(std::format("Status: {}", patStatus == PatternStatus::eSuccessful ? "Success" : (patStatus == PatternStatus::eFailed ? "Fail" : "Overlap")));
        printOnCanvas(std::format("Sector: {:d}", pat.sector()));
        printOnCanvas(std::format("OverlapSector: {:d}", pat.isSectorOverlap() ? pat.secondarySector() : -1));

        bool drawnTrueLabel{true};
        for (const xAOD::MuonSegment* segment : truthSegs) {
            drawSegment(*segment, localToGlobalBucket, lines, drawnTrueLabel, *canvas, view);
            paintSimHits(*geoCtx, localToGlobalBucket, *segment, lines, view);
        }
        canvas->add(std::move(lines));
            
        std::string legendLabel = std::format("Event: {:}, chamber : {:}, #{:}-view ({:})",
                                                ctx.eventID().event_number(),
                                                bucket.msSector()->identString(),
                                                view ==View::objViewEta ? "eta" : (view ==View::objViewPhi ? "phi" : (view == View::objViewZR ? "ZR" : "RZ")),
                                                nameTag);
        canvas->add(drawLabel(legendLabel, 0.15, 0.96));
    }

plotPatternBuckets() [1/4]

void MuonValR4::FastRecoVisualizationTool::plotPatternBuckets ( const EventContext & ctx, const std::string & extraLabel, PatternHitVisualInfo && patternVisual ) const

finaloverridevirtual

Definition at line 126 of file FastRecoVisualizationTool.cxx.

                                                                                                   {
        PrimitiveVec primitives{};
        plotPatternBuckets(ctx, extraLabel, std::move(patternVisual), std::move(primitives));
    }

plotPatternBuckets() [2/4]

void MuonValR4::FastRecoVisualizationTool::plotPatternBuckets ( const EventContext & ctx, const std::string & extraLabel, PatternHitVisualInfo && patternVisual, PrimitiveVec && extraPaints ) const

finaloverridevirtual

Definition at line 133 of file FastRecoVisualizationTool.cxx.

                                                                                        {
        for (const MuonR4::SpacePointBucket* bucket : patternVisual.parentBuckets) {
            PatternHitVisualInfo patternVisualCopy {patternVisual};
            PrimitiveVec extraPaintsCopy {clone(extraPaints)};
            plotPatternBucket(ctx, extraLabel, *bucket, std::move(patternVisualCopy), std::move(extraPaintsCopy));
        }
    }

plotPatternBuckets() [3/4]

void MuonValR4::FastRecoVisualizationTool::plotPatternBuckets ( const EventContext & ctx, const std::string & extraLabel, PatternHitVisualInfoVec && patternVisualVec ) const

finaloverridevirtual

Definition at line 106 of file FastRecoVisualizationTool.cxx.

                                                                                                          {
        PrimitiveVec primitives{};
        plotPatternBuckets(ctx, extraLabel, std::move(patternVisualVec), std::move(primitives));
    }

plotPatternBuckets() [4/4]

void MuonValR4::FastRecoVisualizationTool::plotPatternBuckets ( const EventContext & ctx, const std::string & extraLabel, PatternHitVisualInfoVec && patternVisualVec, PrimitiveVec && extraPaints ) const

finaloverridevirtual

Loop over the pattern visual objects. We make a plot for every combination of bucket and pattern

Definition at line 112 of file FastRecoVisualizationTool.cxx.

                                                                                         {
        if (patternVisualVec.empty()) {
            ATH_MSG_VERBOSE("No pattern visual info available. Do not create visualization.");
            return;
        }
        for (PatternHitVisualInfo& patVisual : patternVisualVec) {
            PrimitiveVec primitivesCopy {clone(primitives)};
            plotPatternBuckets(ctx, extraLabel, std::move(patVisual), std::move(primitivesCopy));
        }
    }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic<bool> m_plotsDone MuonValR4::FastRecoVisualizationTool::ATLAS_THREAD_SAFE {false}

mutableprivate

Flag toggling whether all Canvases have been exhausted.

Definition at line 247 of file FastRecoVisualizationTool.h.

{false};

m_canvasLimit

UnsignedIntegerProperty MuonValR4::FastRecoVisualizationTool::m_canvasLimit {this, "CanvasLimits", 5000}

private

Maximum canvases to draw.

Definition at line 200 of file FastRecoVisualizationTool.h.

{this, "CanvasLimits", 5000};

m_canvasPrefix

StringProperty MuonValR4::FastRecoVisualizationTool::m_canvasPrefix {this, "CanvasPreFix", ""}

private

Prefix of the individual canvas file names <MANDATORY>

Definition at line 206 of file FastRecoVisualizationTool.h.

{this, "CanvasPreFix", ""};

m_clientToken

IRootVisualizationService::ClientToken MuonValR4::FastRecoVisualizationTool::m_clientToken {}

private

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

Definition at line 198 of file FastRecoVisualizationTool.h.

{};

m_detMgr

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

private

pointer to the Detector manager

Definition at line 241 of file FastRecoVisualizationTool.h.

{nullptr};

m_displayOnlyTruth

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_displayOnlyTruth {this, "displayTruthOnly", false}

private

Toggle to print pattern buckets only if they contain truth hits.

Definition at line 236 of file FastRecoVisualizationTool.h.

{this, "displayTruthOnly", false}; 

m_displayOnlyWithPattern

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_displayOnlyWithPattern {this, "displayOnlyWithPattern", true}

private

Toggle to print pattern buckets only if they contain pattern hits.

Definition at line 238 of file FastRecoVisualizationTool.h.

{this, "displayOnlyWithPattern", true}; 

m_doEtaBucketViews

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_doEtaBucketViews {this,"doEtaBucketViews", true}

private

Switch to visualize the eta view of the bucket event.

Definition at line 210 of file FastRecoVisualizationTool.h.

{this,"doEtaBucketViews", true};

m_doPhiBucketViews

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_doPhiBucketViews {this,"doPhiBucketViews", false}

private

Switch to visualize the phi view of the bucket event.

Definition at line 212 of file FastRecoVisualizationTool.h.

{this,"doPhiBucketViews", false};

m_doRZBucketViews

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_doRZBucketViews {this,"doRZBucketViews", false}

private

Definition at line 213 of file FastRecoVisualizationTool.h.

{this,"doRZBucketViews", false};

m_geoCtxKey

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

private

Geometry context key to retrieve the alignment.

Definition at line 243 of file FastRecoVisualizationTool.h.

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

m_idHelperSvc

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

private

Service Handle to the IMuonIdHelperSvc.

Definition at line 245 of file FastRecoVisualizationTool.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_paintFailedPatterns

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_paintFailedPatterns {this, "PaintFailedPatterns", false, "Toggle the display of failed patterns in the visualization"}

private

Switch to visualize failed patterns.

Definition at line 221 of file FastRecoVisualizationTool.h.

{this, "PaintFailedPatterns", false, "Toggle the display of failed patterns in the visualization"};

m_paintOverlapPatterns

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_paintOverlapPatterns {this, "PaintOverlapPatterns", false, "Toggle the display of overlap patterns in the visualization"}

private

Switch to visualize overlap patterns.

Definition at line 223 of file FastRecoVisualizationTool.h.

{this, "PaintOverlapPatterns", false, "Toggle the display of overlap patterns in the visualization"};

m_paintSuccessfullPatterns

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_paintSuccessfullPatterns {this, "PaintSuccessfullPatterns", true, "Toggle the display of successfully built patterns in the visualization"}

private

Switch to visualize successfull patterns.

Definition at line 219 of file FastRecoVisualizationTool.h.

{this, "PaintSuccessfullPatterns", true, "Toggle the display of successfully built patterns in the visualization"};

m_paintTruthHits

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_paintTruthHits {this, "paintTruthHits", false}

private

Switch to visualize the truth hits.

Definition at line 215 of file FastRecoVisualizationTool.h.

{this, "paintTruthHits", false};

m_paintTruthSegment

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_paintTruthSegment {this, "paintTruthSegment", false}

private

Switch to visualize the truth segment.

Definition at line 217 of file FastRecoVisualizationTool.h.

{this, "paintTruthSegment", false};

m_prepContainerKeys

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

private

Declare dependency on the prep data containers.

Definition at line 225 of file FastRecoVisualizationTool.h.

{this, "PrdContainer", {}};

m_saveSinglePDFs

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_saveSinglePDFs {this, "saveSinglePDFs", false}

private

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

Definition at line 202 of file FastRecoVisualizationTool.h.

{this, "saveSinglePDFs", false};

m_saveSummaryPDF

BooleanProperty MuonValR4::FastRecoVisualizationTool::m_saveSummaryPDF {this, "saveSummaryPDF", false}

private

If set to true a summary Canvas is created.

Definition at line 204 of file FastRecoVisualizationTool.h.

{this, "saveSummaryPDF",  false};

m_subDir

StringProperty MuonValR4::FastRecoVisualizationTool::m_subDir {this, "outSubDir", ""}

private

Define the subdirectory in which the plots shall be saved.

Definition at line 208 of file FastRecoVisualizationTool.h.

{this, "outSubDir", ""};

m_truthLinkDecorKeys

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

private

Declaration of the dependency on the decorations.

(Overwritten in initialize)

Definition at line 229 of file FastRecoVisualizationTool.h.

{this, "LinkDecorKeys", {}};

m_truthLinkDecors

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

private

Definition at line 233 of file FastRecoVisualizationTool.h.

{};

m_truthSegLinks

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

private

List of truth segment links to fetch.

Definition at line 227 of file FastRecoVisualizationTool.h.

{this, "TruthSegDecors", {}};

m_visualSvc

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

private

Service handle of the visualization service.

Definition at line 196 of file FastRecoVisualizationTool.h.

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

---

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

• FastRecoVisualizationTool.h
• FastRecoVisualizationTool.cxx