#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 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.
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, Canvas_t &canvas, DynamicLegend &legend, const unsigned int view, unsigned int fillStyle) const

Private Types
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
template<class SpacePointType>
bool	drawHits (const MuonR4::SpacePointBucket &bucket, const std::vector< SpacePointType > &hitsToDraw, Canvas_t &canvasDim, DynamicLegend &legend, 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.
template<class SpacePointType>
const MuonR4::SpacePoint *	drawHit (const SpacePointType &hit, Canvas_t &canvas, DynamicLegend &legend, const unsigned int view, unsigned int fillStyle) const
	Converts a Hit into a particular TBox/ TEllipse for drawing.
template<class SpacePointType>
void	writeChi2 (const MuonR4::SegmentFit::Parameters &pars, const std::vector< SpacePointType > &hits, Canvas_t &canvas, const double legX=0.2, double startLegY=0.8, const double endLegY=0.3) const
	Writes the chi2 of the hits onto the Canvas.
void	paintSimHits (const EventContext &ctx, const xAOD::MuonSegment &truthSeg, Canvas_t &canvas, const int view) const
	Paints the truth sim hits associated with the segment.

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.
Gaudi::Property< unsigned int >	m_canvasLimit {this, "CanvasLimits", 5000}
	Maximum canvases to draw.
Gaudi::Property< bool >	m_saveSinglePDFs {this, "saveSinglePDFs", false}
	If set to true each canvas is saved into a dedicated pdf file.
Gaudi::Property< bool >	m_saveSummaryPDF {this, "saveSummaryPDF", false}
	If set to true a summary Canvas is created.
Gaudi::Property< std::string >	m_canvasPrefix {this, "CanvasPreFix", ""}
	Prefix of the individual canvas file names <MANDATORY>.
Gaudi::Property< std::string >	m_subDir {this, "outSubDir", ""}
	Define the subdirectory in which the plots shall be saved.
Gaudi::Property< bool >	m_displayBucket {this, "displayBucket", true}
	Display the surrounding hits from the bucket not part of the seed.
Gaudi::Property< bool >	m_accumlIsEta {this, "AccumulatorsInEtaPlane", true}
	Swtich toggling whether the accumulator view are in the eta or phi plane.
Gaudi::Property< bool >	m_doEtaBucketViews {this,"doEtaBucketViews", true}
	Switch to visualize the eta view of the bucket event.
Gaudi::Property< bool >	m_doPhiBucketViews {this,"doPhiBucketViews", false}
	Switch to visualize the phi view of the bucket event.
Gaudi::Property< bool >	m_paintTruthHits {this, "paintTruthHits", false}
	Switch to visualize the truth hits.
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 {}
Gaudi::Property< bool >	m_displayOnlyTruth {this, "displayTruthOnly", false}
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	pointer to the Detector manager
ActsTrk::GeoContextReadKey_t	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 {false}
	Flag toggling whether all Canvases have been exhausted.

Detailed Description

Definition at line 133 of file PatternVisualizationTool.h.

Member Typedef Documentation

◆ Canvas_t

using MuonValR4::PatternVisualizationTool::Canvas_t = IRootVisualizationService::ICanvasObject

private

Definition at line 193 of file PatternVisualizationTool.h.

◆ Edges

using MuonValR4::PatternVisualizationTool::Edges = Canvas_t::AxisRanges

private

Definition at line 194 of file PatternVisualizationTool.h.

◆ LabeledSegmentSet

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

Definition at line 181 of file PatternVisualizationTool.h.

◆ SegLink_t

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

private

Definition at line 283 of file PatternVisualizationTool.h.

◆ SegLinkDecor_t

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

private

Definition at line 285 of file PatternVisualizationTool.h.

◆ SegLinkVec_t

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

private

Definition at line 284 of file PatternVisualizationTool.h.

Member Function Documentation

◆ drawHit() [1/2]

template<class SpacePointType>

const SpacePoint * MuonValR4::PatternVisualizationTool::drawHit	(	const SpacePointType &	hit,
		Canvas_t &	canvas,
		DynamicLegend &	legend,
		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 502 of file PatternVisualizationTool.cxx.

                                                                            {
        
        if ((view == objViewEta && !hit.measuresEta()) || (view == objViewPhi && !hit.measuresPhi())) {
            return nullptr;
        }
        
        if (hit.type() != xAOD::UncalibMeasType::Other) {
            canvas.expandPad(hit.localPosition()[view] - hit.driftRadius(), 
                             hit.localPosition().z()   - hit.driftRadius());
            canvas.expandPad(hit.localPosition()[view] + hit.driftRadius(), 
                             hit.localPosition().z()   + hit.driftRadius());
        }
 
        const SpacePoint* underlyingSp{nullptr};
        constexpr int invalidCalibFill = 3305;
        if constexpr (std::is_same_v<SpacePointType, SpacePoint>) {
            ATH_MSG_VERBOSE("drawHit called with SpacePoint");
            underlyingSp = &hit;
            if (hit.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(hit.primaryMeasurement());
                if (dc && dc->status() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                    fillStyle = invalidCalibFill;
                }
            }
        } else if constexpr(std::is_same_v<SpacePointType, CalibratedSpacePoint>) {
            ATH_MSG_VERBOSE("drawHit called with CalibratedSpacePoint");
            underlyingSp = hit.spacePoint();
                if (hit.fitState() == CalibratedSpacePoint::State::Valid) {
                    fillStyle  = fullFilling;
                } else if (hit.fitState() == CalibratedSpacePoint::State::FailedCalib) {
                    fillStyle = invalidCalibFill;
                } else  {
                    fillStyle = hatchedFilling;
                }
        }
        else{
            ATH_MSG_VERBOSE("drawHit called with unsupported SpacePointType");
        }
 
        //TODO: investigate MuonSegmentFittingAlg.PatternVisualizationTool throws seg fault without check but the calibrated space point should have reference space point no?
        if (!underlyingSp){
            ATH_MSG_VERBOSE("Underlying space point not found, skipping hit");
            return nullptr;
        }
 
        const auto* primaryMeas   = underlyingSp->primaryMeasurement();
        const auto* secondaryMeas = underlyingSp->secondaryMeasurement();
 
        //If there is a secondary measurement and it is not matched, choose a different colour to the cases where we have primary and it is matched
        //Need to cast secondary measurement to the respective det type? 
        auto labeledColor = (secondaryMeas && !isLabeled(*secondaryMeas)) ? kOrange - 3 : truthColor;
 
        const auto covarianceWidth = [&]() -> double {
            const double variance = std::max(0., underlyingSp->covariance()[view]);
            //In case of strip it would be too small to visualize the hit, so we set a minimum width of 5 mm, should we add sqrt(12) to get the full width of the strip?
            return std::max(5. * Gaudi::Units::mm, std::sqrt(variance));
        };
 
        const auto addLabeledOutline = [&](const double boxWidth, const double boxHeight) {
            if (!isLabeled(*primaryMeas)) {
                return;
            }
            // Draw a dedicated hollow overlay so the truth-color border is always visible.
            auto outline = drawBox(hit.localPosition(), boxWidth, boxHeight, labeledColor, hollowFilling, view);
            outline->SetFillStyle(hollowFilling);
            outline->SetLineColor(labeledColor);
            TObject* p_outline = outline.get();
            canvas.add(std::move(outline), "l");
            legend.addOnce(LegendItem::LabeledBox, p_outline, "TrueSimHitMatch", "f");
        };
 
        // Add the hit to the legend depending on the fill style (outlier, full, or hatched)
        const auto addHitLegendByFill = [&](TObject* object,
                                            const LegendItem bucketItem,
                                            const char* bucketLabel,
                                            const LegendItem onObjectItem,
                                            const char* onObjectLabel, const char* option = "f") {
 
            if (fillStyle == hatchedFilling) {
                legend.addOnce(LegendItem::OutlierHit, object, "Outlier", option);
                return;
            }
            if (fillStyle == fullFilling) {
                legend.addOnce(onObjectItem, object, onObjectLabel, option);
                return;
            }
 
            // Hits in the bucket with a hollow filling
            legend.addOnce(bucketItem, object, bucketLabel, option);
        };
 
        switch(hit.type()) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(primaryMeas);
                canvas.add(drawDriftCircle(hit.localPosition(), dc->readoutElement()->innerTubeRadius(), kBlack, hollowFilling));
                auto driftCircle = drawDriftCircle(hit.localPosition(), hit.driftRadius(), kBlue, fillStyle);
                TObject* p_driftCircle = driftCircle.get();
                canvas.add(std::move(driftCircle));
 
                //Unforunately the legend will be a box ... to have a point we could make TGraph with a point and add it to the legend but then we would have to draw the hit as a TGrapg as well, so for now we keep it as a box
                addHitLegendByFill(p_driftCircle,
                                   LegendItem::MdtHit,
                                   "MDT inBucket",
                                   LegendItem::MdtHitOnObject,
                                   "MDT onObject", "f");
 
                //In case the hit is also a truth hit, change the line colour to indicate that
                if (isLabeled(*dc)) {
                    auto labeledDriftCircle = drawDriftCircle(hit.localPosition(), hit.driftRadius(), labeledColor, hollowFilling);
                    TObject* p_labeledDriftCircle = labeledDriftCircle.get();
                    canvas.add(std::move(labeledDriftCircle));
                    legend.addOnce( LegendItem::LabeledTube, p_labeledDriftCircle, "TrueSimMdtHitMatch", "f");
                }
                break;
            } case xAOD::UncalibMeasType::RpcStripType: {
                const auto* meas{static_cast<const xAOD::RpcMeasurement*>(primaryMeas)};
                const double boxWidth = 0.5*std::sqrt(12)*std::sqrt(underlyingSp->covariance()[view]);
                auto rpcBox = drawBox(hit.localPosition(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   kGreen + 2, fillStyle);
                TObject* p_rpcBox = rpcBox.get();
                canvas.add(std::move(rpcBox)); 
                addHitLegendByFill(p_rpcBox,
                                   LegendItem::RpcHit,
                                   "RPC inBucket",
                                   LegendItem::RpcHitOnObject,
                                   "RPC onObject");
                addLabeledOutline(boxWidth, 0.5*meas->readoutElement()->gasGapPitch());
                break; 
            } case xAOD::UncalibMeasType::TgcStripType: {
                const auto* meas{static_cast<const xAOD::TgcStrip*>(primaryMeas)};
                const double boxWidth = 0.5*std::sqrt(12)*std::sqrt(underlyingSp->covariance()[view]);
                auto tgcBox = drawBox(hit.localPosition(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   kCyan + 2, fillStyle);
                TObject* p_tgcBox = tgcBox.get();
                canvas.add(std::move(tgcBox));
                addHitLegendByFill(p_tgcBox,
                                   LegendItem::TgcHit,
                                   "TGC inBucket",
                                   LegendItem::TgcHitOnObject,
                                   "TGC onObject");
                addLabeledOutline(boxWidth, 0.5*meas->readoutElement()->gasGapPitch());
                break; 
            } case xAOD::UncalibMeasType::MMClusterType: {
                const double boxWidth = covarianceWidth();
                constexpr double boxHeight = 10.*Gaudi::Units::mm;
                auto mmBox = drawBox(hit.localPosition(), boxWidth, boxHeight, kAquamarine, fillStyle, view);
                TObject* p_mmBox = mmBox.get();
                canvas.add(std::move(mmBox));
 
                addHitLegendByFill(p_mmBox,
                                   LegendItem::MmHit,
                                   "MMG inBucket",
                                   LegendItem::MmHitOnObject,
                                   "MMG onObject");
                addLabeledOutline(boxWidth, boxHeight);
                break; 
            }  case xAOD::UncalibMeasType::Other: {
                break;
            }  case xAOD::UncalibMeasType::sTgcStripType: {
                const double boxWidth = covarianceWidth();
                const double boxHeight = 10.*Gaudi::Units::mm;
                auto stgcBox = drawBox(hit.localPosition(), boxWidth, boxHeight, kTeal, fillStyle, view);
 
 
                //In case of pad use a transparent filling to see the underlying strip or wire
                //TODO: do more splitting into strip+wire, strip+pad, wire+pad, strip+wire+pad and add legend accordingly?
                LegendItem legendType = LegendItem::StgcStripWireHit;
                const auto* primary = static_cast<const xAOD::sTgcMeasurement*>( primaryMeas );
                if (primary && primary->channelType() == xAOD::sTgcMeasurement::sTgcChannelTypes::Pad) {
                    stgcBox->SetFillColorAlpha(kTeal, 0.1);
                    legendType = LegendItem::StgcPadHit;
                }
                TObject* p_stgcBox = stgcBox.get();
 
                canvas.add(std::move(stgcBox));
                if (legendType == LegendItem::StgcPadHit) {
                    addHitLegendByFill(p_stgcBox,
                                       LegendItem::StgcPadHit,
                                       "sTGCp inBucket",
                                       LegendItem::StgcPadHitOnObject,
                                       "sTGCp onObject");
                } else {
                    addHitLegendByFill(p_stgcBox,
                                       LegendItem::StgcStripWireHit,
                                       "sTGCs+w inBucket",
                                       LegendItem::StgcStripWireHitOnObject,
                                       "sTGCs+w onObject");
                }
                addLabeledOutline(boxWidth, boxHeight);
                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::PatternVisualizationTool::drawHit	(	const SpacePointType &	hit,
		Canvas_t &	canvas,
		DynamicLegend &	legend,
		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
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::PatternVisualizationTool::drawHits	(	const MuonR4::SpacePointBucket &	bucket,
		const std::vector< SpacePointType > &	hitsToDraw,
		Canvas_t &	canvasDim,
		DynamicLegend &	legend,
		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
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 705 of file PatternVisualizationTool.cxx.

                                                                         {
 
        SpacePointSet drawnPoints{};
 
        for (const SpacePointType& hit : hitsToDraw) {            
            drawnPoints.insert(drawHit(*hit, canvas, legend, 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, canvas, legend, view, hollowFilling);
            } 
        }
        return drawnPoints.size() - drawnPoints.count(nullptr) > 0;
    }

◆ 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 97 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 108 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 52 of file PatternVisualizationTool.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));
        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 86 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 90 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();
    }

◆ paintSimHits()

void MuonValR4::PatternVisualizationTool::paintSimHits	(	const EventContext &	ctx,
		const xAOD::MuonSegment &	truthSeg,
		Canvas_t &	canvas,
		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
canvas	Reference to the Canvas object to which the drawn hits are appended
view	Draw the hit either in the eta or phi view

Definition at line 237 of file PatternVisualizationTool.cxx.

                                                                      {
        if (!m_paintTruthHits) {
            return;
        }
        auto truthHits = getMatchingSimHits(truthSeg);
        const ActsTrk::GeometryContext* 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()->globalToLocalTransform(*geoCtx) *
                                         re->localToGlobalTransform(*geoCtx, hash);
            const Amg::Vector3D locPos = trf * xAOD::toEigen(simHit->localPosition());
            const Amg::Vector3D locDir = trf.linear() * xAOD::toEigen(simHit->localDirection());
            canvas.add(drawArrow(locPos, locDir, truthColor, kDashed, view));
        }
    }

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

Definition at line 127 of file PatternVisualizationTool.cxx.

                                                                                         {
        if (m_plotsDone) {
            return;
        }
 
        ATH_MSG_VERBOSE("Visualize accumulator");
 
        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);
 
        std::vector<const SpacePoint*> spacePointsInAcc{};
        for (const std::size_t bin : accumulator.getNonEmptyBins()) {
            const auto [xBin, yBin] = accumulator.axisBins(bin);
            auto hitIds = accumulator.hitIds(xBin, yBin); 
            spacePointsInAcc.insert(spacePointsInAcc.end(),hitIds.begin(), hitIds.end());
            accHisto->SetBinContent(xBin+1, yBin+1, accumulator.nHits(bin));
        }
     
        const LabeledSegmentSet truthSegs{getLabeledSegments(spacePointsInAcc)};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            ATH_MSG_VERBOSE("visualizeAccumulator skipped: no truth segments found and displayOnlyTruth=true");
            return;
        }
 
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, extraLabel);
        if (!canvas){
            m_plotsDone = true;
            return;
        }
 
 
        const double maxBins = std::max(accumulator.nBinsX(), accumulator.nBinsY());
        double markerTextSize = 0.035;
        // Scale down for large accumulators
        markerTextSize *= 25. / std::max(25., maxBins);
        // Avoid absurdly tiny/large text
        markerTextSize = std::clamp(markerTextSize, 0.006, 0.035);
        accHisto->SetMarkerSize(markerTextSize);
        accHisto->SetMarkerColor(kBlack);
        accHisto->SetMinimum(0.);
 
        canvas->expandPad(axisRanges.xMin, axisRanges.yMin);
        canvas->expandPad(axisRanges.xMax, axisRanges.yMax);
        canvas->setAxisTitles(std::format("tan#{}", m_accumlIsEta ? "beta" : "#alpha"),
                              std::format("{:}_{{0}} [mm]", m_accumlIsEta ? "y" : "x"));        
        canvas->add(std::move(accHisto), "HIST SAME");
 
        // Draw explicit bin labels at bin centers. This is more robust than TH2 TEXT
        // when plotting into the visualization service's prebuilt frame.
        const double binLabelPx = std::clamp(1.2 * 500. / maxBins, 7.0, 18.0);
        for (const std::size_t bin : accumulator.getNonEmptyBins()) {
            const auto [xBin, yBin] = accumulator.axisBins(bin);
            const double xCenter = axisRanges.xMin + (xBin + 0.5) * (axisRanges.xMax - axisRanges.xMin) / accumulator.nBinsX();
            const double yCenter = axisRanges.yMin + (yBin + 0.5) * (axisRanges.yMax - axisRanges.yMin) / accumulator.nBinsY();
 
            //Extract number of entries in the bin with no decimal precision just int
            std::string binLabel = std::format("{:0}", int(accumulator.nHits(bin)));
 
            auto binTxt = drawLabel(binLabel, xCenter, yCenter, binLabelPx, false, kBlack);
            binTxt->SetTextAlign(22);
            canvas->add(std::move(binTxt));
        }
 
        int iseg = 0;
        for (const xAOD::MuonSegment* segment : truthSegs) {
            const auto [pos, dir] = makeLine(localSegmentPars(*segment));
            const double tan = m_accumlIsEta ? houghTanBeta(dir) : houghTanAlpha(dir);
            const double icept = pos[m_accumlIsEta ? objViewEta : objViewPhi];
            auto truthMarker = std::make_unique<TMarker>(tan, icept, kFullCrossX);
            truthMarker->SetMarkerColor(truthColor);
            truthMarker->SetMarkerSize(4);
            canvas->add(std::move(truthMarker));
            canvas->add(drawLabel(std::format("true parameters: {:}",
                                              makeLabel(localSegmentPars(*segment))),0.2, 0.9 - 0.05*iseg));
            iseg += 1;
        }
        for (const auto& maximum : maxima) {
            auto maxMarker = std::make_unique<TMarker>(maximum.x, maximum.y, kFullTriangleUp);
            maxMarker->SetMarkerColor(parLineColor);
            maxMarker->SetMarkerSize(4);
            canvas->add(std::move(maxMarker));
 
            // Draw a bounding box around the maximum island center (x,y) and widths (wx,wy).
            const double xMin = maximum.x - maximum.wx;
            const double xMax = maximum.x + maximum.wx;
            const double yMin = maximum.y - maximum.wy;
            const double yMax = maximum.y + maximum.wy;
 
            auto maxBox = drawBox(xMin, yMin, xMax, yMax, parLineColor, hollowFilling);
            maxBox->SetLineStyle(kDashed);
            maxBox->SetLineWidth(2);
            canvas->add(std::move(maxBox));
        }
 
        canvas->add(std::move(primitives));
    }

◆ visualizeBucket() [1/2]

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

finaloverridevirtual

Definition at line 330 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

reset the primitives

Definition at line 336 of file PatternVisualizationTool.cxx.

                                                                                    {
        if (m_plotsDone) {
            return;
        }
        ATH_MSG_VERBOSE("visualizeBucket called for " << extraLabel);
 
        LabeledSegmentSet truthSegs{getLabeledSegments(Acts::unpackConstSmartPointers(bucket))};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            ATH_MSG_VERBOSE("visualizeBucket skipped: no truth segments found and displayOnlyTruth=true");
            return;
        }
 
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
 
            const std::string_view viewName = view == objViewEta ? "eta" : "phi";
 
            auto canvas = m_visualSvc->prepareCanvas( ctx, m_clientToken, std::format("{}_{}view", extraLabel, viewName));
 
 
            if (!canvas) {
                m_plotsDone = true;
                return;
            }
 
            DynamicLegend legend(0.8, 0.2, 0.95, 0.5);
 
            canvas->add(clone(primitives));
            if (!drawHits(bucket, bucket, *canvas, legend, view)) {
                canvas->trash();
                continue;
            }
            bool drawnTrueLabel{false};
            for (const xAOD::MuonSegment* segment : truthSegs) {
 
                auto truthLine =  drawLine(localSegmentPars(*segment), canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh), truthColor, kDotted, view);
                TLine* line = static_cast<TLine*>(truthLine.get());
                canvas->add( std::move(truthLine) );
                legend.addOnce( LegendItem::TruthSegmentLine, line, "Truth Segment", "l" );
 
                if (!drawnTrueLabel) {
                    canvas->add(drawLabel(std::format("true parameters: {:}",makeLabel(localSegmentPars(*segment))),0.2, 0.89));
                    drawnTrueLabel = true;
                }
                paintSimHits(ctx,*segment, *canvas, view);
            }
            
            std::string legendLabel = std::format("Event: {:}, chamber : {:}, #{:}-view ({:})",
                                                  ctx.eventID().event_number(),
                                                  bucket.msSector()->identString(),
                                                  view ==objViewEta ? "eta" : "phi",
                                                  extraLabel);
            canvas->add(drawLabel(legendLabel, 0.15, 0.96));
 
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
 
            if (!legend.empty()) {
                canvas->add(legend.release(), "same");
            }
 
        }
    }

◆ visualizeSeed() [1/2]

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

finaloverridevirtual

Definition at line 261 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

Definition at line 267 of file PatternVisualizationTool.cxx.

                                                                                  {
        
        ATH_MSG_VERBOSE("Visualizing seed with " << seed.getHitsInMax().size() << " hits");
        if (m_plotsDone) {
            ATH_MSG_VERBOSE("visualizeSeed skipped: canvas quota already exhausted for " << extraLabel);
            return;
        }
        const LabeledSegmentSet truthSegs{getLabeledSegments(seed.getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            ATH_MSG_VERBOSE("visualizeSeed skipped: no truth segments found and displayOnlyTruth=true");
            return;
        }
 
       
 
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
 
            std::string_view viewName = view == objViewEta ? "eta" : "phi";
 
            auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, std::format("{}_{}", extraLabel, viewName));
 
            if (!canvas) {
                m_plotsDone = true;
                return;
            }
 
            DynamicLegend legend;
            canvas->add(clone(primitives));
 
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
 
            if (!drawHits(*seed.parentBucket(), seed.getHitsInMax(), *canvas, legend, view)) {
                continue;
            }
            for (const xAOD::MuonSegment* segment : truthSegs) {
                canvas->add(drawLine(localSegmentPars(*segment), 
                                              canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh),
                                              truthColor, kDotted, view));
                paintSimHits(ctx,*segment, *canvas, view);
            }
            canvas->add(drawLine(seed.parameters(), canvas->corner(Edges::yLow), 
                                 canvas->corner(Edges::yHigh), parLineColor, kDashed, view));
        
            writeChi2(seed.parameters(), seed.getHitsInMax(), *canvas);
        
            std::string legendLabel = std::format("Event: {:}, chamber : {:}, #{:}-view ({:})",
                                                  ctx.eventID().event_number(),
                                                  m_idHelperSvc->toStringChamber(seed.getHitsInMax().front()->identify()),
                                                  view ==objViewEta ? "eta" : "phi",
                                                  extraLabel);
            canvas->add(drawLabel(legendLabel, 0.1, 0.96));
            canvas->add(drawLabel( "Seed parameters: " + makeLabel(seed.parameters()),0.25, 0.89));
        }
    }

◆ visualizeSegment() [1/2]

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

finaloverridevirtual

Definition at line 408 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

Definition at line 415 of file PatternVisualizationTool.cxx.

                                                                                     {
        if (m_plotsDone) {
            return;
        }
 
        ATH_MSG_VERBOSE("Visualizing segment with " << segment.measurements().size() << " hits");
 
        const LabeledSegmentSet truthSegs{getLabeledSegments(segment.parent()->getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
        const ActsTrk::GeometryContext* geoCtx{nullptr};
        if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
            return;
        }
        
 
        const Parameters segPars  = SegmentFit::localSegmentPars(*geoCtx, segment);
        
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
 
            const std::string_view viewName = view == objViewEta ? "eta" : "phi";
 
            auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, std::format("{}_{}view", extraLabel, viewName));
            if (!canvas) {
                m_plotsDone = true;
                return;
            }
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
            canvas->add(clone(primitives));
 
            DynamicLegend legend(0.8, 0.2, 0.95, 0.5);
 
 
            ATH_MSG_DEBUG("Drawing hits!");
            if (!drawHits(*segment.parent()->parentBucket(), segment.measurements(), 
                          *canvas, legend, view)) {
                canvas->trash();
                continue;
            }
 
            ATH_MSG_DEBUG("Drawing chi2!");
            writeChi2(segPars, segment.measurements(), *canvas);
 
 
            {
                auto segmentline = drawLine(segPars, canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh), parLineColor, kDashed, view);
                TLine *line = static_cast<TLine*>(segmentline.get());
                canvas->add(std::move(segmentline));
                legend.addOnce(LegendItem::RecoSegmentLine, line, "Reco Segment", "l");
            }
 
            for (const xAOD::MuonSegment* tru_segment : truthSegs) {
                if(!tru_segment) continue;
 
                auto truthLine =  drawLine(localSegmentPars(*tru_segment), canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh), truthColor, kDotted, view);
                TLine* line = static_cast<TLine*>(truthLine.get());
                canvas->add( std::move(truthLine) );
                legend.addOnce( LegendItem::TruthSegmentLine, line, "Truth Segment", "l" );
                paintSimHits(ctx,*tru_segment, *canvas, view);
            }
 
            const Identifier canvasId{segment.parent()->getHitsInMax().front()->identify()};
            std::string legendLabel=std::format("Event: {:}, chamber: {:}, #chi^{{2}} / nDoF: {:.2f} ({:d}), #{:}-view (:)", 
                                                ctx.eventID().event_number(), m_idHelperSvc->toStringChamber(canvasId),
                                                segment.chi2() /std::max(1u, segment.nDoF()), segment.nDoF(),
                                                view ==objViewEta ? "eta" : "phi", extraLabel);
 
            canvas->add(drawLabel(legendLabel, 0.2, 0.96));
            canvas->add(drawLabel(makeLabel(segPars),0.25, 0.91));
 
            if (!legend.empty()) {
                canvas->add(legend.release(), "same");
            }
        }
    }

◆ writeChi2()

template<class SpacePointType>

void MuonValR4::PatternVisualizationTool::writeChi2	(	const MuonR4::SegmentFit::Parameters &	pars,
		const std::vector< SpacePointType > &	hits,
		Canvas_t &	canvas,
		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
canvas	Reference to the Canvas object to which the drawn hits are appended
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 728 of file PatternVisualizationTool.cxx.

                                                                             {
        const auto [pos, dir] = makeLine(pars);
     
        unsigned int nHits = 0;
        for (const SpacePointType& hit : hits) { 
            const SpacePoint* underlyingSp{nullptr};
            bool displayChi2{true};
            if constexpr(std::is_same_v<SpacePointType, Segment::MeasType>) {
                underlyingSp = hit->spacePoint();
                displayChi2 = (hit->fitState() == CalibratedSpacePoint::State::Valid);               
            } else {
                underlyingSp = hit;
            }
 
            ATH_MSG_VERBOSE("Writing chi2 for hit " << nHits << " of type " << hit->type());
 
            const Identifier hitId =  underlyingSp ? underlyingSp->identify(): Identifier{};
            std::string legendstream{};
            switch(hit->type()) {
                case xAOD::UncalibMeasType::MdtDriftCircleType: {
                    const int driftSign{SeedingAux::strawSign(pos, dir, *hit)};
                    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) {
                //Make thi chi2 view specific?
                const double chi2 = SeedingAux::chi2Term(pos, dir,*hit);                
                legendstream+=std::format(", #chi^{{2}}: {:.2f}", chi2);
            } else {
                legendstream+=", NotValidState";
            }
 
 
            ++nHits;
 
            canvas.add(drawLabel(legendstream, legX, startLegY, 8));
            startLegY -= 0.02;
            if (startLegY<= endLegY) {
                break;
            }
        }
    }

Member Data Documentation

◆ 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 270 of file PatternVisualizationTool.h.

270{this, "AccumulatorsInEtaPlane", true};

◆ m_canvasLimit

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

private

Maximum canvases to draw.

Definition at line 257 of file PatternVisualizationTool.h.

257{this, "CanvasLimits", 5000};

◆ m_canvasPrefix

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

private

Prefix of the individual canvas file names <MANDATORY>.

Definition at line 263 of file PatternVisualizationTool.h.

263{this, "CanvasPreFix", ""};

◆ m_clientToken

IRootVisualizationService::ClientToken MuonValR4::PatternVisualizationTool::m_clientToken {}

private

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

Definition at line 255 of file PatternVisualizationTool.h.

255{};

◆ m_detMgr

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

private

pointer to the Detector manager

Definition at line 291 of file PatternVisualizationTool.h.

291{nullptr};

◆ 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 267 of file PatternVisualizationTool.h.

267{this, "displayBucket", true};

◆ m_displayOnlyTruth

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

private

Definition at line 288 of file PatternVisualizationTool.h.

288{this, "displayTruthOnly", false};

◆ 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 272 of file PatternVisualizationTool.h.

272{this,"doEtaBucketViews", true};

◆ m_doPhiBucketViews

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

private

Switch to visualize the phi view of the bucket event.

Definition at line 274 of file PatternVisualizationTool.h.

274{this,"doPhiBucketViews", false};

◆ m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonValR4::PatternVisualizationTool::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Geometry context key to retrieve the alignment.

Definition at line 293 of file PatternVisualizationTool.h.

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

◆ m_idHelperSvc

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

private

Service Handle to the IMuonIdHelperSvc.

Definition at line 295 of file PatternVisualizationTool.h.

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

◆ m_paintTruthHits

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

private

Switch to visualize the truth hits.

Definition at line 276 of file PatternVisualizationTool.h.

276{this, "paintTruthHits", false};

◆ m_plotsDone

std::atomic<bool> MuonValR4::PatternVisualizationTool::m_plotsDone {false}

mutableprivate

Flag toggling whether all Canvases have been exhausted.

Definition at line 297 of file PatternVisualizationTool.h.

297{false};

◆ m_prepContainerKeys

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

private

Declare dependency on the prep data containers.

Definition at line 278 of file PatternVisualizationTool.h.

278{this, "PrdContainer", {}};

◆ 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 259 of file PatternVisualizationTool.h.

259{this, "saveSinglePDFs", false};

◆ m_saveSummaryPDF

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

private

If set to true a summary Canvas is created.

Definition at line 261 of file PatternVisualizationTool.h.

261{this, "saveSummaryPDF", false};

◆ m_subDir

Gaudi::Property<std::string> MuonValR4::PatternVisualizationTool::m_subDir {this, "outSubDir", ""}

private

Define the subdirectory in which the plots shall be saved.

Definition at line 265 of file PatternVisualizationTool.h.

265{this, "outSubDir", ""};

◆ 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 282 of file PatternVisualizationTool.h.

282{this, "LinkDecorKeys", {}};

◆ m_truthLinkDecors

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

private

Definition at line 286 of file PatternVisualizationTool.h.

286{};

◆ 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 280 of file PatternVisualizationTool.h.

280{this, "TruthSegDecors", {}};

◆ m_visualSvc

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

private

Service handle of the visualization service.

Definition at line 252 of file PatternVisualizationTool.h.

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

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

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Canvas_t

◆ Edges

◆ LabeledSegmentSet

◆ SegLink_t

◆ SegLinkDecor_t

◆ SegLinkVec_t

Member Function Documentation

◆ drawHit() [1/2]

◆ drawHit() [2/2]

◆ drawHits()

◆ getLabeledSegments() [1/2]

◆ getLabeledSegments() [2/2]

◆ initialize()

◆ isLabeled() [1/2]

◆ isLabeled() [2/2]

◆ paintSimHits()

◆ visualizeAccumulator() [1/2]

◆ visualizeAccumulator() [2/2]

◆ visualizeBucket() [1/2]

◆ visualizeBucket() [2/2]

◆ visualizeSeed() [1/2]

◆ visualizeSeed() [2/2]

◆ visualizeSegment() [1/2]

◆ visualizeSegment() [2/2]

◆ writeChi2()

Member Data Documentation

◆ m_accumlIsEta

◆ m_canvasLimit

◆ m_canvasPrefix

◆ m_clientToken

◆ m_detMgr

◆ m_displayBucket

◆ m_displayOnlyTruth

◆ m_doEtaBucketViews

◆ m_doPhiBucketViews

◆ m_geoCtxKey

◆ m_idHelperSvc

◆ m_paintTruthHits

◆ m_plotsDone

◆ m_prepContainerKeys

◆ m_saveSinglePDFs

◆ m_saveSummaryPDF

◆ m_subDir

◆ m_truthLinkDecorKeys

◆ m_truthLinkDecors

◆ m_truthSegLinks

◆ m_visualSvc