MuonValR4::PatternVisualizationTool Class Reference

#include <PatternVisualizationTool.h>

Inheritance diagram for MuonValR4::PatternVisualizationTool:

Collaboration diagram for MuonValR4::PatternVisualizationTool:

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

Public Member Functions
virtual StatusCode	initialize () override final
virtual 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, 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, 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, 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
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 {false}
	Flag toggling whether all Canvases have been exhausted.

Detailed Description

Definition at line 29 of file PatternVisualizationTool.h.

Member Typedef Documentation

Canvas_t

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

private

Definition at line 89 of file PatternVisualizationTool.h.

Edges

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

private

Definition at line 90 of file PatternVisualizationTool.h.

LabeledSegmentSet

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

Definition at line 77 of file PatternVisualizationTool.h.

SegLink_t

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

private

Definition at line 179 of file PatternVisualizationTool.h.

SegLinkDecor_t

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

private

Definition at line 181 of file PatternVisualizationTool.h.

SegLinkVec_t

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

private

Definition at line 180 of file PatternVisualizationTool.h.

Member Function Documentation

drawHit() [1/2]

template<class SpacePointType>

const SpacePoint * MuonValR4::PatternVisualizationTool::drawHit	(	const SpacePointType &	hit,
		Canvas_t &	canvas,
		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 394 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>) {
            underlyingSp = &hit;
            if (hit.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(hit.primaryMeasurement());
                if (dc->status() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                    fillStyle = invalidCalibFill;
                }
            }
        } else if constexpr(std::is_same_v<SpacePointType, CalibratedSpacePoint>) {
            underlyingSp = hit.spacePoint();
            if (hit.fitState() == CalibratedSpacePoint::State::Valid) {
                fillStyle  = fullFilling;
            } else if (hit.fitState() == CalibratedSpacePoint::State::FailedCalib) {
                fillStyle = invalidCalibFill;
            } else  {
                fillStyle = hatchedFilling;
            }
        }
        switch(hit.type()) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(underlyingSp->primaryMeasurement());
                canvas.add(drawDriftCircle(hit.localPosition(), dc->readoutElement()->innerTubeRadius(), 
                                                     kBlack, hollowFilling));
 
                const int circColor = isLabeled(*dc) ? truthColor : kBlue;                    
                canvas.add(drawDriftCircle(hit.localPosition(), 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()[view]);
                canvas.add(drawBox(hit.localPosition(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   boxColor, fillStyle));
                break; 
            } case xAOD::UncalibMeasType::TgcStripType: {
                const auto* meas{static_cast<const xAOD::TgcStrip*>(underlyingSp->primaryMeasurement())};
                const int boxColor = isLabeled(*meas) ? truthColor : kCyan + 2;
                const double boxWidth = 0.5*std::sqrt(12)*std::sqrt(underlyingSp->covariance()[view]);
                canvas.add(drawBox(hit.localPosition(), boxWidth, 0.5*meas->readoutElement()->gasGapPitch(),
                                   boxColor, fillStyle));
                break; 
            } case xAOD::UncalibMeasType::MMClusterType: {
                const int boxColor = isLabeled(*underlyingSp->primaryMeasurement()) ? truthColor : kAquamarine;
                const double boxWidth = 5*Gaudi::Units::mm;
                canvas.add(drawBox(hit.localPosition(), boxWidth, 10.*Gaudi::Units::mm, boxColor, fillStyle));
                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(hit.localPosition(), boxWidth, 10.*Gaudi::Units::mm, boxColor, fillStyle));
                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, 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, 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 475 of file PatternVisualizationTool.cxx.

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

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 94 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 105 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 49 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 83 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 87 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 187 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 116 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 124 of file PatternVisualizationTool.cxx.

                                                                                         {

        if (m_plotsDone) {
            return;
        }
        if (accumulator.getNonEmptyBins().empty()) {
            ATH_MSG_WARNING("Hough accumulator is empty");
            return;
        }
 
        auto accHisto = std::make_unique<TH2F>("AccumulatorHisto", "histo",
                                                accumulator.nBinsX(), axisRanges.xMin, axisRanges.xMax,
                                                accumulator.nBinsY(), axisRanges.yMin, axisRanges.yMax); 
        accHisto->SetDirectory(nullptr);
 
        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) {
            return;
        }
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, extraLabel);
        if (!canvas){
            m_plotsDone = true;
            return;
        }
        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");
 
        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(8);
            canvas->add(std::move(truthMarker));
            canvas->add(drawLabel(std::format("true parameters: {:}",
                                              makeLabel(localSegmentPars(*segment))),0.2, 0.9));
        }
        for (const auto& maximum : maxima) {
            auto maxMarker = std::make_unique<TMarker>(maximum.x, maximum.y, kFullTriangleUp);
            maxMarker->SetMarkerColor(parLineColor);
            maxMarker->SetMarkerSize(8);
            canvas->add(std::move(maxMarker));
        }
        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 270 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 276 of file PatternVisualizationTool.cxx.

                                                                                    {
        if (m_plotsDone) {
            return;
        }
 
        LabeledSegmentSet truthSegs{getLabeledSegments(Acts::unpackConstSmartPointers(bucket))};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
       auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, extraLabel);
        if (!canvas){
            m_plotsDone = true;
            return;
        }
        canvas->add(std::move(primitives));
       
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
            if (!drawHits(bucket, bucket, *canvas, view)) {
                continue;
            }
            bool drawnTrueLabel{false};
            for (const xAOD::MuonSegment* segment : truthSegs) {
                canvas->add(drawLine(localSegmentPars(*segment), 
                                     canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh),
                                     truthColor, kDotted, view));
                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));
        }
    }

visualizeSeed() [1/2]

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

finaloverridevirtual

Definition at line 211 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 217 of file PatternVisualizationTool.cxx.

                                                                                  {
        
        if (m_plotsDone) {
            return;
        }
        const LabeledSegmentSet truthSegs{getLabeledSegments(seed.getHitsInMax())};
        if (truthSegs.empty() && m_displayOnlyTruth) {
            return;
        }
 
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, extraLabel);
        if (!canvas) {
            m_plotsDone = true;
            return;
        }
        canvas->add(std::move(primitives));
       
 
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
 
            if (!drawHits(*seed.parentBucket(), seed.getHitsInMax(), *canvas, 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(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 327 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 334 of file PatternVisualizationTool.cxx.

                                                                                     {
        if (m_plotsDone) {
            return;
        }
 
        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;
        }
        auto canvas = m_visualSvc->prepareCanvas(ctx, m_clientToken, extraLabel);
        if (!canvas) {
            m_plotsDone = true;
            return;
        }
        canvas->add(std::move(primitives));
        
 
        const Parameters segPars  = SegmentFit::localSegmentPars(*geoCtx, segment);
        
        for (const int view : {objViewEta, objViewPhi}) {
            if ((view == objViewEta && !m_doEtaBucketViews) ||
                (view == objViewPhi && !m_doPhiBucketViews)){
                continue;
            }
            canvas->setAxisTitles(std::format("{:} [mm]", view == objViewEta ? 'y' : 'x'), "z [mm]");
            if (!drawHits(*segment.parent()->parentBucket(), segment.measurements(), 
                          *canvas, 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);
            }
            writeChi2(segPars, segment.measurements(), *canvas);
 
            canvas->add(drawLine(segPars, canvas->corner(Edges::yLow), canvas->corner(Edges::yHigh),
                                          parLineColor, kDashed, 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));
        }
    }

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 496 of file PatternVisualizationTool.cxx.

                                                                             {
        const auto [pos, dir] = makeLine(pars);
     
        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;
            }
            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) {
                const double chi2 = SeedingAux::chi2Term(pos, dir,*hit);                
                legendstream+=std::format(", #chi^{{2}}: {:.2f}", chi2);
            } else {
                legendstream+=", #chi^{2}: ---";
            }
            canvas.add(drawLabel(legendstream, legX, startLegY, 14));
            startLegY -= 0.05;
            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 166 of file PatternVisualizationTool.h.

{this, "AccumulatorsInEtaPlane", true}; 

m_canvasLimit

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

private

Maximum canvases to draw.

Definition at line 153 of file PatternVisualizationTool.h.

{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 159 of file PatternVisualizationTool.h.

{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 151 of file PatternVisualizationTool.h.

{};

m_detMgr

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

private

pointer to the Detector manager

Definition at line 187 of file PatternVisualizationTool.h.

{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 163 of file PatternVisualizationTool.h.

{this, "displayBucket", true};

m_displayOnlyTruth

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

private

Definition at line 184 of file PatternVisualizationTool.h.

{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 168 of file PatternVisualizationTool.h.

{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 170 of file PatternVisualizationTool.h.

{this,"doPhiBucketViews", false};

m_geoCtxKey

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

private

Geometry context key to retrieve the alignment.

Definition at line 189 of file PatternVisualizationTool.h.

{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 191 of file PatternVisualizationTool.h.

{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 172 of file PatternVisualizationTool.h.

{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 193 of file PatternVisualizationTool.h.

{false};

m_prepContainerKeys

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

private

Declare dependency on the prep data containers.

Definition at line 174 of file PatternVisualizationTool.h.

{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 155 of file PatternVisualizationTool.h.

{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 157 of file PatternVisualizationTool.h.

{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 161 of file PatternVisualizationTool.h.

{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 178 of file PatternVisualizationTool.h.

{this, "LinkDecorKeys", {}};

m_truthLinkDecors

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

private

Definition at line 182 of file PatternVisualizationTool.h.

{};

m_truthSegLinks

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

private

List of truth segment links to fetch.

Definition at line 176 of file PatternVisualizationTool.h.

{this, "TruthSegDecors", {}};

m_visualSvc

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

private

Service handle of the visualization service.

Definition at line 148 of file PatternVisualizationTool.h.

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

---

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

• PatternVisualizationTool.h
• PatternVisualizationTool.cxx