#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 void	visualizeSegmentsMeasurementsObj (const EventContext &ctx, const MuonR4::Segment &segment, const std::string &extraLabel) const override final
virtual void	visualizeSegmentsMeasurementsObj (const EventContext &ctx, const MuonR4::Segment::MeasVec &measVec, const std::string &extraLabel) 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.
void	drawObjHits (const ActsTrk::GeometryContext &geoCtx, const MuonR4::Segment::MeasVec &measVec, Acts::ObjVisualization3D &visualHelper) const
	Append hits from a segment in an obj file.

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

◆ Edges

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

private

Definition at line 99 of file PatternVisualizationTool.h.

◆ LabeledSegmentSet

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

Definition at line 86 of file PatternVisualizationTool.h.

◆ SegLink_t

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

private

Definition at line 197 of file PatternVisualizationTool.h.

◆ SegLinkDecor_t

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

private

Definition at line 199 of file PatternVisualizationTool.h.

◆ SegLinkVec_t

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

private

Definition at line 198 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 511 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 592 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;
    }

◆ drawObjHits()

void MuonValR4::PatternVisualizationTool::drawObjHits	(	const ActsTrk::GeometryContext &	geoCtx,
		const MuonR4::Segment::MeasVec &	measVec,
		Acts::ObjVisualization3D &	visualHelper ) const

private

Append hits from a segment in an obj file.

Parameters

geoCtx	The reference to the geometry context used fro the local to global transformations
measVec	The reference of the measurements from the segment that are visualized
visualHelper	The Acts Obj visualization helper
viewConfig	The ACTS viewConfig reference

Definition at line 457 of file PatternVisualizationTool.cxx.

                                                                                           {
 
 
        const SpacePoint* sp = measVec.front()->type() != xAOD::UncalibMeasType::Other ? measVec.front()->spacePoint() : 
                               measVec[1]->spacePoint();
      
        const MuonGMR4::SpectrometerSector* msSector  = sp->msSector();  
        const Amg::Transform3D& locToGlob = msSector->localToGlobalTransform(geoCtx); 
        using CovIdx = SpacePoint::CovIdx;
        double dX{0.}, dY{0.};
 
        for(const auto& meas : measVec){
          
            //if this is a 2D measurement visualize it as the spacepoint
                      
            if(meas->dimension() == 2){
                //handle straw surfaces
                if(meas->isStraw()){                   
                    const double dR = meas->type() == xAOD::UncalibMeasType::Other ? std::sqrt(meas->covariance()[Acts::toUnderlying(CovIdx::etaCov)]):
                    meas->driftRadius();
                    const double hZ = std::sqrt(meas->covariance()[Acts::toUnderlying(CovIdx::phiCov)]);
                    auto bounds = std::make_unique<Acts::LineBounds>(dR, hZ);
                    Amg::Vector3D globalPos = locToGlob* meas->localPosition();    
                    const Acts::Transform3 trf = Acts::Transform3(
                    Acts::Translation3(globalPos) *locToGlob.rotation());                    
                    auto surface = Acts::Surface::makeShared<Acts::StrawSurface>(trf, std::move(bounds));    
                    Acts::GeometryView3D::drawSurface(visualHelper, *surface, geoCtx.context());    
                    continue;                
                }
                
                dX = std::sqrt(meas->covariance()[Acts::toUnderlying(CovIdx::phiCov)]);
                dY = std::sqrt(meas->covariance()[Acts::toUnderlying(CovIdx::etaCov)]);
                auto bounds = std::make_unique<Acts::RectangleBounds>(dX, dY);               
                Amg::Vector3D globalPos = locToGlob* meas->localPosition();    
                const Acts::Transform3 trf = Acts::Transform3(
                Acts::Translation3(globalPos) *locToGlob.rotation());   
               
                auto surf = Acts::Surface::makeShared<Acts::PlaneSurface>(trf,std::move(bounds));
                Acts::GeometryView3D::drawSurface(visualHelper, *surf, geoCtx.context());          
            }else{
            if(meas->type() == xAOD::UncalibMeasType::Other){
                continue;
            }
            const SpacePoint* underlyingSp{meas->spacePoint()};
            MuonValR4::drawMeasurement(geoCtx, underlyingSp->primaryMeasurement(), visualHelper); 
            } 
        }
    }

◆ 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 207 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 136 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 144 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 290 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 296 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 231 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 237 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 347 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 354 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));
        }
    }

◆ visualizeSegmentsMeasurementsObj() [1/2]

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

finaloverridevirtual

Definition at line 412 of file PatternVisualizationTool.cxx.

                                                                                                       {
                                                                      
        const ActsTrk::GeometryContext* geoCtx{nullptr};
        if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
            return;
        }
        Acts::ObjVisualization3D visualHelper{};
        const MuonR4::Segment::MeasVec& measurements{segment.measurements()};  
        drawObjHits(*geoCtx, measurements, visualHelper);
        const SpacePoint* sp = measurements.front()->type() != xAOD::UncalibMeasType::Other ? measurements.front()->spacePoint() : 
                               measurements[1]->spacePoint();
        auto chamberId = sp->identify();
 
        //draw also the segment line in the same obj and in the end write the obj file with the visualHelper
        double pathLength{1.*Gaudi::Units::m};      
        Acts::GeometryView3D::drawSegment(visualHelper,
                                         segment.position() + 0.5* pathLength * segment.direction(),
                                         segment.position() - 0.5* pathLength  * segment.direction(),
                                         Acts::s_viewLine);
        std::string fileName = std::format("Event_{:}_chamber_{:}_{:}",  
                           ctx.eventID().event_number(), m_idHelperSvc->toStringChamber(chamberId), extraLabel);
        visualHelper.write(fileName + ".obj");   
                                                                        
    }

◆ visualizeSegmentsMeasurementsObj() [2/2]

void MuonValR4::PatternVisualizationTool::visualizeSegmentsMeasurementsObj	(	const EventContext &	ctx,
		const MuonR4::Segment::MeasVec &	measVec,
		const std::string &	extraLabel ) const

finaloverridevirtual

Definition at line 439 of file PatternVisualizationTool.cxx.

                                                                                                       {
        const ActsTrk::GeometryContext* geoCtx{nullptr};
        if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
            return;
        }
 
        Acts::ObjVisualization3D visualHelper{};
        drawObjHits(*geoCtx, measVec, visualHelper);
        const SpacePoint* sp = measVec.front()->type() != xAOD::UncalibMeasType::Other ? measVec.front()->spacePoint() : 
                               measVec[1]->spacePoint();
        auto chamberId = sp->identify();
        std::string fileName = std::format("Event_{:}_chamber_{:}_{:}",  
                           ctx.eventID().event_number(), m_idHelperSvc->toStringChamber(chamberId), extraLabel);
        visualHelper.write(fileName + ".obj");        
    }

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

184{this, "AccumulatorsInEtaPlane", true};

◆ m_canvasLimit

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

private

Maximum canvases to draw.

Definition at line 171 of file PatternVisualizationTool.h.

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

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

169{};

◆ m_detMgr

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

private

pointer to the Detector manager

Definition at line 205 of file PatternVisualizationTool.h.

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

181{this, "displayBucket", true};

◆ m_displayOnlyTruth

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

private

Definition at line 202 of file PatternVisualizationTool.h.

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

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

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

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

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

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

211{false};

◆ m_prepContainerKeys

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

private

Declare dependency on the prep data containers.

Definition at line 192 of file PatternVisualizationTool.h.

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

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

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

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

196{this, "LinkDecorKeys", {}};

◆ m_truthLinkDecors

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

private

Definition at line 200 of file PatternVisualizationTool.h.

200{};

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

194{this, "TruthSegDecors", {}};

◆ m_visualSvc

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

private

Service handle of the visualization service.

Definition at line 166 of file PatternVisualizationTool.h.

166{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()

◆ drawObjHits()

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

◆ visualizeSegmentsMeasurementsObj() [1/2]

◆ visualizeSegmentsMeasurementsObj() [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