MuonValR4 Namespace Reference

Lightweight algorithm to read xAOD MDT sim hits and (fast-digitised) drift circles from SG and fill a validation NTuple with identifier and drift circle info. More...

Namespaces
namespace	detail

Classes
class	FastRecoVisualizationTool
class	IFastRecoVisualizationTool
	Helper tool to visualize a pattern recogntion incident or a certain stage of the segment fit. More...
class	IPatternVisualizationTool
	Helper tool to visualize a pattern recogntion incident or a certain stage of the segment fit. More...
class	IRootVisualizationService
	Definition of the IRootVisualizationService interface. More...
class	ITrackVisualizationTool
	Helper tool to visualize a pattern recogntion incident or a certain stage of the segment fit. More...
class	MdtCalibDbAlgTest
class	MdtDriftCircleVariables
class	MdtTwinDriftCircleVariables
class	MmClusterVariables
class	MsTrackTester
class	MuonFastRecoTester
class	MuonHitTesterAlg
class	MuonHoughTransformTester
class	MuonRecoChainTester
class	MuonSPCalibrationTest
class	PatternVisualizationTool
class	RootVisualizationService
	Implementation of the IRootVisualization service. More...
class	RpcMeasurementVariables
class	SegmentExtpTest
class	SegmentRefitTest
	Simple tester class to refit the Mdt segments with the Acts global chi2 fitter In the ideal case, the Acts fit should return the same parameters as the Muon segment fitter with the same measurements to be included on the fit. More...
class	SimHitTester
class	SpacePointTesterModule
class	TesterModuleBase
class	TgcStripVariables
class	TrackContainerModule
class	TrackSummaryModule
class	TrackSummaryValueBranch
	Helper branch class to dump a pick a single hit summary value from the overall summary & to dump it in the tree. More...
class	TrackVisualizationTool
class	xMuonHitAnalysis

Typedefs
using	StIndex = Muon::MuonStationIndex::StIndex
using	simHitSet = std::unordered_set<const xAOD::MuonSimHit*>
using	TruthParticleMap = std::map<const xAOD::TruthParticle*, std::vector<simHitSet>>
using	ObjectMatching = MuonHoughTransformTester::ObjectMatching
using	LabeledSegmentSet = PatternVisualizationTool::LabeledSegmentSet
using	Category = MuonR4::HitSummary::HitCategory
using	Status = MuonR4::HitSummary::Status
using	ICanvasObject = RootVisualizationService::ICanvasObject

Functions
std::optional< std::size_t >	isTruthMatched (const SpacePoint *sp, const TruthParticleMap &truthHits)
bool	isInPattern (const SpacePoint *sp, const StIndex station, const GlobalPattern &pattern)
unsigned int	countMatched (const simHitSet &truthHits, const simHitSet &recoHits)
unsigned int	countMatched (const xAOD::MuonSegment *truthSeg, const MuonR4::SegmentSeed *seed)
unsigned int	countMatched (const xAOD::MuonSegment *truthSeg, const MuonR4::Segment *segment)
template<class SpType>
bool	isPrecHit (const SpType &sp)
	Define a spacepoint as precision hit if it's a Mdt or NSW eta hit.
std::string	nameBr (Category cat, Status status, LayerIndex layer, bool isSmall)
int	seedColorIdx (std::size_t iSeed)
std::string	removeNonAlphaNum (std::string str)
	Removes all non-alpha numerical characters from a string.
void	ensureDirectory (const std::string &path)
	Ensures that the subdirectory in the path is created.
void	drawPropagation (const std::vector< Acts::detail::Step > &steps, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewLine)
	Draws the recorded propagation steps as a polygon line.
void	drawBoundParameters (const ActsTrk::GeometryContext &gctx, const Acts::BoundTrackParameters &pars, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewLine, const double standardLength=3.*Gaudi::Units::cm)
	Draw a line representing the bound track parameters.
void	drawSegmentLine (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewLine, const double standardLength=1.*Gaudi::Units::m)
	Draw a segment line inside the obj file.
void	drawSegmentLine (const ActsTrk::GeometryContext &gctx, const MuonR4::Segment &segment, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewLine)
	Draw a segment line inside the obj file.
void	drawSegmentMeasurements (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewSensitive)
	Draw all uncalibrated measurements associated to the segment.
void	drawSegmentMeasurements (const ActsTrk::GeometryContext &gctx, const MuonR4::Segment &segment, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewSensitive)
	Draw all uncalibrated measurements associated to the segment.
void	drawMeasurement (const ActsTrk::GeometryContext &gctx, const xAOD::UncalibratedMeasurement *meas, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewSensitive)
	Draw an uncalibrated measurement inside the obj file.
void	drawSpacePoint (const ActsTrk::GeometryContext &gctx, const MuonR4::SpacePoint &spacePoint, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewSensitive)
	Draw an uncalibrated space point inside the obj file.
void	drawSpacePoint (const ActsTrk::GeometryContext &gctx, const MuonR4::CalibratedSpacePoint &spacePoint, const MuonGMR4::SpectrometerSector *msSector, Acts::ObjVisualization3D &visualHelper, const Acts::ViewConfig &viewConfig=Acts::s_viewSensitive)
	Draw a calibrated space point inside the obj file.
std::vector< std::unique_ptr< TObject > >	clone (const std::vector< std::unique_ptr< TObject > > &cloneMe)
std::unique_ptr< TEllipse >	drawDriftCircle (const Amg::Vector3D &center, const double radius, const int color=kViolet, const int fillStyle=hollowFilling)
	Create a TEllipse for drawing a drift circle.
std::unique_ptr< TBox >	drawBox (const Amg::Vector3D &boxCenter, const double boxWidth, const double boxHeight, const int color=kGreen+2, const int fillStyle=hollowFilling, const int view=objViewEta)
	Creates a box for drawing, e.g strip measurements.
std::unique_ptr< TBox >	drawBox (const double x1, const double y1, const double x2, const double y2, const int color=kGreen+2, const int fillStyle=hollowFilling)
	Creates a box for drawing, e.g strip measurements.
std::unique_ptr< TLine >	drawLine (const MuonR4::SegmentFit::Parameters &pars, const double lowEnd, const double highEnd, const int color=kRed+1, const int lineStyle=kDashed, const int view=objViewEta)
	Draws a line from the segment fit parameters.
std::unique_ptr< TLine >	drawLine (const Amg::Vector3D &lowEnd, const Amg::Vector3D &highEnd, const int color=kRed+1, const int lineStyle=kSolid, const int view=objViewEta)
	Draw a line between two endpoints in the y-z or the x-z plane.
std::unique_ptr< TArrow >	drawArrow (const Amg::Vector3D &start, const Amg::Vector3D &dir, const int color=kRed+1, const int lineStyle=kDashed, const int view=objViewEta)
	Draw an arror between two endpoints in the y-z or the x-z plane.
std::unique_ptr< TLatex >	drawLabel (const std::string &text, const double xPos, const double yPos, const double textSize=18, const bool useNDC=true, const int color=kBlack)
	Create a TLatex label,.
std::unique_ptr< TLatex >	drawAtlasLabel (const double xPos, const double yPos, const std::string &status="Internal")
	Create a ATLAS label.
std::unique_ptr< TLatex >	drawLumiSqrtS (const double xPos, const double yPos, const std::string_view sqrtS="14", const std::string_view lumi="")
	Create a luminosity sqrtS label.

Variables
constexpr int	hollowFilling = 0
	Filling codes for hollow / fullFilling / hatched filling.
constexpr int	fullFilling = 1001
constexpr int	hatchedFilling = 3344
constexpr int	objViewEta = Acts::toUnderlying(MuonR4::SegmentFit::AxisDefs::etaCov)
	ObjectView.
constexpr int	objViewPhi = Acts::toUnderlying(MuonR4::SegmentFit::AxisDefs::phiCov)

Detailed Description

Lightweight algorithm to read xAOD MDT sim hits and (fast-digitised) drift circles from SG and fill a validation NTuple with identifier and drift circle info.

Module to dump the basic properties of the TgcStrip collection.

Module to dump the basic properties of the RpcMeasurement collection.

Module to dump the basic properties of the MmCluster collection.

Module to dump the basic properties of the MdtTwinDriftCircle collection.

Module to dump the basic properties of the MdtDriftCircle collection.

Typedef Documentation

Category

using MuonValR4::Category = MuonR4::HitSummary::HitCategory

Definition at line 14 of file TrackSummaryModule.cxx.

ICanvasObject

using MuonValR4::ICanvasObject = RootVisualizationService::ICanvasObject

Definition at line 33 of file RootVisualizationService.cxx.

LabeledSegmentSet

using MuonValR4::LabeledSegmentSet = PatternVisualizationTool::LabeledSegmentSet

Definition at line 47 of file PatternVisualizationTool.cxx.

ObjectMatching

using MuonValR4::ObjectMatching = MuonHoughTransformTester::ObjectMatching

Definition at line 28 of file MuonHoughTransformTester.cxx.

simHitSet

typedef std::unordered_set< const xAOD::MuonSimHit * > MuonValR4::simHitSet = std::unordered_set<const xAOD::MuonSimHit*>

Definition at line 17 of file MuonFastRecoTester.cxx.

Status

using MuonValR4::Status = MuonR4::HitSummary::Status

Definition at line 15 of file TrackSummaryModule.cxx.

StIndex

using MuonValR4::StIndex = Muon::MuonStationIndex::StIndex

Definition at line 16 of file MuonFastRecoTester.cxx.

TruthParticleMap

using MuonValR4::TruthParticleMap = std::map<const xAOD::TruthParticle*, std::vector<simHitSet>>

Definition at line 18 of file MuonFastRecoTester.cxx.

Function Documentation

clone()

std::vector< std::unique_ptr< TObject > > MuonValR4::clone

(

const std::vector< std::unique_ptr< TObject > > &

cloneMe

)

Definition at line 13 of file VisualizationHelpers.cxx.

                                                                                              {
        std::vector<std::unique_ptr<TObject>> cloned{};
        for (auto& obj : cloneMe) {
            cloned.emplace_back(obj->Clone());
        }
        return cloned;
    }

countMatched() [1/3]

unsigned int MuonValR4::countMatched	(	const simHitSet &	truthHits,
		const simHitSet &	recoHits )

Definition at line 30 of file MuonHoughTransformTester.cxx.

                                                         {
        unsigned int matched{0};
        for (const xAOD::MuonSimHit* reco : recoHits) {
            matched += truthHits.count(reco);
        }
        return matched;
    }

countMatched() [2/3]

unsigned int MuonValR4::countMatched	(	const xAOD::MuonSegment *	truthSeg,
		const MuonR4::Segment *	segment )

Definition at line 42 of file MuonHoughTransformTester.cxx.

                                                            {
        return truthSeg ? countMatched(getMatchingSimHits(*truthSeg), getMatchingSimHits(*segment)) : 0;
    }

countMatched() [3/3]

unsigned int MuonValR4::countMatched	(	const xAOD::MuonSegment *	truthSeg,
		const MuonR4::SegmentSeed *	seed )

Definition at line 38 of file MuonHoughTransformTester.cxx.

                                                             {
        return truthSeg ? countMatched(getMatchingSimHits(*truthSeg), getMatchingSimHits(*seed)) : 0;
    }

drawArrow()

std::unique_ptr< TArrow > MuonValR4::drawArrow	(	const Amg::Vector3D &	start,
		const Amg::Vector3D &	dir,
		const int	color = kRed +1,
		const int	lineStyle = kDashed,
		const int	view = objViewEta )

Draw an arror between two endpoints in the y-z or the x-z plane.

Parameters

start	Lower start point of the arrow
dir	Direction of the arrow
color	Color of the line (Cf. TColor documentation)
lineStyle	Style of the drawn line (cf. TAttLine documentation)
view	Is the line placed in the y-z or in the x-z plane

Definition at line 30 of file VisualizationHelpers.cxx.

                                                                                           {
        constexpr double arrowLength = 2.*Gaudi::Units::cm; 
        const Amg::Vector3D end = start + (arrowLength / std::hypot(dir[view], dir.z()) ) * dir;
        auto arrow = std::make_unique<TArrow>(start[view], start.z(), end[view], end.z(),0.01);
        arrow->SetLineColor(color);
        arrow->SetLineWidth(2);
        arrow->SetLineStyle(lineStyle);
        return arrow;
    }

drawAtlasLabel()

std::unique_ptr< TLatex > MuonValR4::drawAtlasLabel	(	const double	xPos,
		const double	yPos,
		const std::string &	status = "Internal" )

Create a ATLAS label.

Parameters

xPos	x-position of the label on the Canvas
yPos	y-position of the label on the Canvas
status	ATLAS label status to be drawn

Definition at line 97 of file VisualizationHelpers.cxx.

                                                                    {
        return drawLabel( "#font[72]{ATLAS} "+status, xPos, yPos);
    }

drawBoundParameters()

void MuonValR4::drawBoundParameters	(	const ActsTrk::GeometryContext &	gctx,
		const Acts::BoundTrackParameters &	pars,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewLine,
		const double	standardLength = 3.*Gaudi::Units::cm )

Draw a line representing the bound track parameters.

Parameters

gctx	Geometry context to align the parameters globally
pars	Bound track parameters to draw
vsualHelper	Obj helper to which the drawn line is appended
viewConfig	Configuration style of the drawn line
standardLength	Length of the segment as a fallback solution

Definition at line 238 of file ObjVisualizationHelpers.cxx.

                                                         {
        const Amg::Vector3D globPos = pars.position(gctx.context());
        const Amg::Vector3D start = globPos - 0.5 * standardLength * pars.direction();
        const Amg::Vector3D end   = globPos + 0.5 * standardLength * pars.direction();
        Acts::GeometryView3D::drawSegment(visualHelper, start, end, viewConfig);
    }

drawBox() [1/2]

std::unique_ptr< TBox > MuonValR4::drawBox	(	const Amg::Vector3D &	boxCenter,
		const double	boxWidth,
		const double	boxHeight,
		const int	color = kGreen +2,
		const int	fillStyle = hollowFilling,
		const int	view = objViewEta )

Creates a box for drawing, e.g strip measurements.

Parameters

boxCenter	Center of the box to be placed expressed in chamber frame coordinates
boxWidth	Width of the drawn box
boxHeight	Height of the drawn box
color	Color of the surrounding line & filling
fillStyle	Box fill style
view	Is the box placed in the y-z or in the x-z plane

Definition at line 54 of file VisualizationHelpers.cxx.

                                                   {
        return drawBox(boxCenter[view] - 0.5*boxWidth, boxCenter.z() - 0.5*boxHeight,
                       boxCenter[view] + 0.5*boxWidth, boxCenter.z() + 0.5*boxHeight,
                                    color, fillStyle); 
    }

drawBox() [2/2]

std::unique_ptr< TBox > MuonValR4::drawBox	(	const double	x1,
		const double	y1,
		const double	x2,
		const double	y2,
		const int	color = kGreen +2,
		const int	fillStyle = hollowFilling )

Creates a box for drawing, e.g strip measurements.

Parameters

x1	Left edge location
y1	Bottom edge location
x2	Right edge location
y2	TopEdgeLocation
color	Color of the surrounding line & filling
fillStyle	Box fill style
view	Is the box placed in the y-z or in the x-z plane

Definition at line 62 of file VisualizationHelpers.cxx.

                                                                        {
        auto box = std::make_unique<TBox>(x1,y1,x2,y2);
        box->SetFillColor(color);
        box->SetLineColor(color);
        box->SetFillStyle(fillStyle);
        box->SetFillColorAlpha(color, 0.8);
        return box;
    }

drawDriftCircle()

std::unique_ptr< TEllipse > MuonValR4::drawDriftCircle	(	const Amg::Vector3D &	center,
		const double	radius,
		const int	color = kViolet,
		const int	fillStyle = hollowFilling )

Create a TEllipse for drawing a drift circle.

Parameters

center	Position of the drift cirle expressed in the chambers frame y-coordinate corresponds to the tube layer z-coordinate corresponds to the tube in the layer
radius	Radius of the drift circle to draw
color	Color of the circle to draw
fillStyle	Style to pick the filling of the circle

Definition at line 20 of file VisualizationHelpers.cxx.

                                                                   {
        auto ellipse = std::make_unique<TEllipse>(center.y(), center.z(), radius);
        ellipse->SetLineColor(color);
        ellipse->SetFillStyle(fillStyle);
        ellipse->SetLineWidth(1);
        ellipse->SetFillColorAlpha(color, 0.2);
        return ellipse;
    }

drawLabel()

std::unique_ptr< TLatex > MuonValR4::drawLabel	(	const std::string &	text,
		const double	xPos,
		const double	yPos,
		const double	textSize = 18,
		const bool	useNDC = true,
		const int	color = kBlack )

Create a TLatex label,.

Parameters

text	Label text
xPos	x-position of the label on the Canvas in relative coordinates
yPos	y-position of the label on the Canvas in relative coordinates
fontSize	Size of the label font
useNDC	Whether to use Normalized Device Coordinates

Definition at line 40 of file VisualizationHelpers.cxx.

                                                       {
        auto tl = std::make_unique<TLatex>(xPos, yPos, text.c_str());
        tl->SetTextFont(43);
        if(useNDC){
            tl->SetNDC();
        } 
        tl->SetTextSize(textSize); 
        tl->SetTextColor(color);
        return tl;
    }

drawLine() [1/2]

std::unique_ptr< TLine > MuonValR4::drawLine	(	const Amg::Vector3D &	lowEnd,
		const Amg::Vector3D &	highEnd,
		const int	color = kRed + 1,
		const int	lineStyle = kSolid,
		const int	view = objViewEta )

Draw a line between two endpoints in the y-z or the x-z plane.

Parameters

lowEnd	Lower boundary in Canvas-y of the line
highEnd	Upper boundaty in Canbas-y of the line
color	Color of the line (Cf. TColor documentation)
lineStyle	Style of the drawn line (cf. TAttLine documentation)
view	Is the line placed in the y-z or in the x-z plane

Definition at line 81 of file VisualizationHelpers.cxx.

                                                    {
        const double x1 = lowEnd[view];
        const double y1 = lowEnd[Amg::z];
        const double x2 = highEnd[view];
        const double y2 = highEnd[Amg::z];
        
        auto seedLine = std::make_unique<TLine>(x1, y1, x2, y2);
        seedLine->SetLineColor(color);
        seedLine->SetLineWidth(2);
        seedLine->SetLineStyle(lineStyle);
        return seedLine;
    
    }

drawLine() [2/2]

std::unique_ptr< TLine > MuonValR4::drawLine	(	const MuonR4::SegmentFit::Parameters &	pars,
		const double	lowEnd,
		const double	highEnd,
		const int	color = kRed +1,
		const int	lineStyle = kDashed,
		const int	view = objViewEta )

Draws a line from the segment fit parameters.

Parameters

pars	Segment fit parameters to extract position & direction from
lowEnd	Lower boundary in Canvas-y of the line
highEnd	Upper boundaty in Canbas-y of the line
color	Color of the line (Cf. TColor documentation)
lineStyle	Style of the drawn line (cf. TAttLine documentation)
view	Is the line placed in the y-z or in the x-z plane

Definition at line 72 of file VisualizationHelpers.cxx.

                                                    {
        const auto [pos, dir] = makeLine(pars);
        return drawLine(pos + Amg::intersect<3>(pos,dir,Amg::Vector3D::UnitZ(), lowEnd).value_or(0.)* dir,
                        pos + Amg::intersect<3>(pos,dir,Amg::Vector3D::UnitZ(), highEnd).value_or(0.)* dir,
                        color, lineStyle, view);
    }

drawLumiSqrtS()

std::unique_ptr< TLatex > MuonValR4::drawLumiSqrtS	(	const double	xPos,
		const double	yPos,
		const std::string_view	sqrtS = "14",
		const std::string_view	lumi = "" )

Create a luminosity sqrtS label.

Parameters

xPos	x-position of the label on the Canvas
yPos	y-position of the label on the Canvas
sqrtS	Centre of mass energy [TeV]
lumi	Luminosity [fb^{-1}]. If less <0 not drawn

Definition at line 101 of file VisualizationHelpers.cxx.

                                                                     {
        return drawLabel(std::format("#sqrt{{s}}={0} TeV {1}{2}", sqrtS, lumi, lumi.empty() ? "" : "fb^{-1}"), xPos, yPos);
    }

drawMeasurement()

void MuonValR4::drawMeasurement	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::UncalibratedMeasurement *	meas,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewSensitive )

Draw an uncalibrated measurement inside the obj file.

The measurement is translated to a temporary surface with adapted position & boundaries (e.g. drift radius or measurement uncertainty)

Parameters

gctx	Geometry context needed to fetch the positions of the surface
meas	Pointer to the muon measurement to visualize
vsualHelper	Obj helper to which the measurement is appended.
viewConfig	Configuration style of the drawn measurement

Combined pseudo measurement

Check whether the measurement is a phi measurement or not

2D RPC or sTGC pad

Definition at line 129 of file ObjVisualizationHelpers.cxx.

                                                           {
        
        ActsTrk::detail::xAODUncalibMeasSurfAcc surfAcc{};
        const Acts::Surface& surf{*surfAcc.get(meas)};
        const Acts::GeometryContext tgContext = gctx.context();
        const auto& bounds = surf.bounds();
        if (meas->type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const auto& lBounds = static_cast<const Acts::LineBounds&>(bounds);
            const auto* driftCirc = static_cast<const xAOD::MdtDriftCircle*>(meas);
            const double dR = driftCirc->driftRadius();
            const double hZ = driftCirc->numDimensions() == 1 ? 
                                    lBounds.get(Acts::LineBounds::eHalfLengthZ) :
                                    std::sqrt(meas->localCovariance<2>()(1,1));
            auto newBounds = std::make_unique<Acts::LineBounds>(dR, hZ);
            auto dummySurface = Acts::Surface::makeShared<Acts::StrawSurface>(surf.localToGlobalTransform(tgContext)*
                                                                              Amg::getTranslate3D(driftCirc->localMeasurementPos()),
                                                                              std::move(newBounds));
            Acts::GeometryView3D::drawSurface(visualHelper, *dummySurface, tgContext,
                                              Amg::Transform3D::Identity(), viewConfig);
            return;
        }
        double dX{0.}, dY{0.};
        Amg::Vector3D locPos{Amg::Vector3D::Zero()};
        switch (meas->numDimensions()) {
            case 0:{
                const auto* cmbMeas = static_cast<const xAOD::CombinedMuonStrip*>(meas);
                const auto [locPos2D, locCov2D] = xAOD::positionAndCovariance(cmbMeas);
                dX = std::sqrt(locCov2D(0,0));
                dY = std::sqrt(locCov2D(1,1));
                locPos.block<2,1>(0,0) = locPos2D;
                break;
            } case 1:{
                if (meas->type() == xAOD::UncalibMeasType::RpcStripType) {
                    const auto* rpcClus = static_cast<const xAOD::RpcMeasurement*>(meas);
                    locPos = rpcClus->localMeasurementPos();
                    dX = rpcClus->measuresPhi() ? 0.5* rpcClus->readoutElement()->stripPhiLength() 
                                                : std::sqrt(rpcClus->localCovariance<1>()(0,0));
                    dY = rpcClus->measuresPhi() ? std::sqrt(rpcClus->localCovariance<1>()(0,0))
                                                : 0.5* rpcClus->readoutElement()->stripEtaLength();
                } else if (meas->type() == xAOD::UncalibMeasType::TgcStripType) {
                    const auto* tgcClus = static_cast<const xAOD::TgcStrip*>(meas);
                    const MuonGMR4::TgcReadoutElement* re = tgcClus->readoutElement();
                    const auto& stripLay = re->sensorLayout(tgcClus->measurementHash());
                    locPos = tgcClus->localMeasurementPos();
                    dX = tgcClus->measuresPhi() ? 0.5* stripLay->design(true).stripLength(tgcClus->channelNumber())
                                                : std::sqrt(tgcClus->localCovariance<1>()(0,0));
                    dY = tgcClus->measuresPhi() ? std::sqrt(tgcClus->localCovariance<1>()(0,0))
                                                : 0.5* stripLay->design(false).stripLength(tgcClus->channelNumber());
                } else if (meas->type() == xAOD::UncalibMeasType::MMClusterType) {
                    const auto* mmClust = static_cast<const xAOD::MMCluster*>(meas);
                    locPos = mmClust->localMeasurementPos();
                    dX = std::sqrt(mmClust->localCovariance<1>()(0,0));
                    dY = 0.5* mmClust->readoutElement()->stripLength(mmClust->measurementHash());
                } else if(meas->type() == xAOD::UncalibMeasType::sTgcStripType) {
                    const auto* sTgcClus = static_cast<const xAOD::sTgcMeasurement*>(meas);
                    locPos = sTgcClus->localMeasurementPos();
                    if (sTgcClus->channelType() == sTgcIdHelper::sTgcChannelTypes::Strip){
                        dX = std::sqrt(sTgcClus->localCovariance<1>()(0,0));
                        dY = 0.5* sTgcClus->readoutElement()->stripDesign(sTgcClus->measurementHash()).stripLength(sTgcClus->channelNumber());
                    } else if (sTgcClus->channelType() == sTgcIdHelper::sTgcChannelTypes::Wire) {
                        dY = std::sqrt(sTgcClus->localCovariance<1>()(0,0));
                        dX = 0.5*sTgcClus->readoutElement()->wireDesign(sTgcClus->measurementHash()).stripLength(sTgcClus->channelNumber());
                    }
                } else if (meas->type() == xAOD::UncalibMeasType::Other) {
                    const auto* pseudo = static_cast<const xAOD::AuxiliaryMeasurement*>(meas);
                    using ProjectorType = xAOD::AuxiliaryMeasurement::ProjectorType;
                    constexpr double measLength = 1._m;
                    if (pseudo->calibProjector() == ProjectorType::e1DimNoTime) {
                        dX = std::sqrt(meas->localCovariance<1>()(0,0));
                        dY = measLength;
                    } else if (pseudo->calibProjector() == ProjectorType::e1DimRotNoTime) {
                        dY = std::sqrt(meas->localCovariance<1>()(0,0));
                        dX = measLength;
                    }
                }
                break;
            } 
            case 2:{
                locPos.block<2,1>(0, 0) = xAOD::toEigen(meas->localPosition<2>());
                dX = std::sqrt(meas->localCovariance<2>()(0,0));
                dY = std::sqrt(meas->localCovariance<2>()(1,1));
                break;
            }
        }
 
        std::shared_ptr<Acts::Surface> dummySurf{};
        
        if (surf.type() == Acts::Surface::SurfaceType::Straw) {
            auto newBounds = std::make_unique<Acts::LineBounds>(dX, dY);
            dummySurf = Acts::Surface::makeShared<Acts::StrawSurface>(surf.localToGlobalTransform(tgContext)*
                                                                      Amg::getTranslate3D(locPos),
                                                                      std::move(newBounds));
 
        } else {
            auto newBounds = std::make_unique<Acts::RectangleBounds>(dX, dY);
            dummySurf = Acts::Surface::makeShared<Acts::PlaneSurface>(surf.localToGlobalTransform(tgContext)*
                                                                      Amg::getTranslate3D(locPos),
                                                                      std::move(newBounds));
 
        }
        Acts::GeometryView3D::drawSurface(visualHelper, *dummySurf, tgContext,
                                          Amg::Transform3D::Identity(), viewConfig);
    }

drawPropagation()

void MuonValR4::drawPropagation	(	const std::vector< Acts::detail::Step > &	steps,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewLine )

Draws the recorded propagation steps as a polygon line.

Parameters

step	List of steps to draw
vsualHelper	Obj helper to which the drawn trajectory is appended
viewConfig	Configuration style of the drawn polygon.

Definition at line 40 of file ObjVisualizationHelpers.cxx.

                                                          {
        
        if (steps.empty()) {
            return;
        }
        Amg::Vector3D start = steps.front().position;
        for (std::size_t s = 1; s < steps.size(); ++s) {
            Amg::Vector3D end = steps[s].position;
            if ( (end - start).mag() > Acts::s_epsilon){
                Acts::GeometryView3D::drawSegment(visualHelper, start, end, viewConfig);
                start = std::move(end);          
            }
 
        }
    }

drawSegmentLine() [1/2]

void MuonValR4::drawSegmentLine	(	const ActsTrk::GeometryContext &	gctx,
		const MuonR4::Segment &	segment,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewLine )

Draw a segment line inside the obj file.

IThe first and last surface positions are used to determine the length of the segment.

Parameters

gctx	Geometry context needed to fetch the positions of the first & last measurement
segment	The segment which is meant to draw
vsualHelper	Obj helper to which the segment is appended.
viewConfig	Configuration style of the drawn line

Take the local z component of the local to global transform as plane normal

Create the intersections

Definition at line 57 of file ObjVisualizationHelpers.cxx.

                                                           {
        const Amg::Transform3D& locToGlob = segment.msSector()->localToGlobalTransform(gctx);
        const Amg::Vector3D firstSurfPos = locToGlob*segment.measurements().front()->localPosition();
        const Amg::Vector3D lastSurfPos  = locToGlob*segment.measurements().back()->localPosition();
        const Amg::Vector3D planeNorm = locToGlob.linear().col(2);
        const auto firstPlaneIsect = intersectPlane(segment.position(), segment.direction(),
                                                    planeNorm, firstSurfPos);
        const auto lastPlaneIsect = intersectPlane(segment.position(), segment.direction(),
                                                    planeNorm, lastSurfPos);
        
        Acts::GeometryView3D::drawSegment(visualHelper,
                                          segment.position() + firstPlaneIsect.pathLength() * segment.direction(),
                                          segment.position() + lastPlaneIsect.pathLength()  * segment.direction(),
                                          viewConfig);
    }

drawSegmentLine() [2/2]

void MuonValR4::drawSegmentLine	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewLine,
		const double	standardLength = 1.*Gaudi::Units::m )

Draw a segment line inside the obj file.

If the segment is a reconstructed segment and has associated measurements, then the first and last surface position are used to determine the length of the segment, otherwise the standard lenth is used.

Parameters

gctx	Geometry context needed to fetch the positions of the first & last measurement
segment	The segment which is meant to draw
vsualHelper	Obj helper to which the segment is appended.
viewConfig	Configuration style of the drawn line
standardLength	Length of the segment as a fallback solution

Take the local z component of the local to global transform as plane normal

Create the intersections

Definition at line 77 of file ObjVisualizationHelpers.cxx.

                                                     {
        
        std::vector<const xAOD::UncalibratedMeasurement*> assocMeas = collectMeasurements(segment, false);
        if (assocMeas.empty()){
            Acts::GeometryView3D::drawSegment(visualHelper,
                                              segment.position() - 0.5 * standardLength * segment.direction(),
                                              segment.position() + 0.5 * standardLength * segment.direction(),
                                              viewConfig);
            return;
        }
        const xAOD::UncalibratedMeasurement* firstMeas = assocMeas.front()->type() != xAOD::UncalibMeasType::Other ?
                                                         assocMeas.front() : assocMeas[1];
        const xAOD::UncalibratedMeasurement* lastMeas = assocMeas.back();
 
        const Amg::Vector3D firstSurfPos = xAOD::muonSurface(firstMeas).center(gctx.context());
        const Amg::Vector3D lastSurfPos  = xAOD::muonSurface(lastMeas).center(gctx.context());
 
        const Segment* detSeg = detailedSegment(segment);
        const Amg::Vector3D planeNorm = detSeg->msSector()->localToGlobalTransform(gctx).linear().col(2);
        const auto firstPlaneIsect = intersectPlane(segment.position(), segment.direction(),
                                                    planeNorm, firstSurfPos);
        const auto lastPlaneIsect = intersectPlane(segment.position(), segment.direction(),
                                                    planeNorm, lastSurfPos);
        
        Acts::GeometryView3D::drawSegment(visualHelper,
                                          segment.position() + firstPlaneIsect.pathLength() * segment.direction(),
                                          segment.position() + lastPlaneIsect.pathLength()  * segment.direction(),
                                          viewConfig);
    }

drawSegmentMeasurements() [1/2]

void MuonValR4::drawSegmentMeasurements	(	const ActsTrk::GeometryContext &	gctx,
		const MuonR4::Segment &	segment,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewSensitive )

Draw all uncalibrated measurements associated to the segment.

Parameters

gctx	Geometry context needed to fetch the positions of the first & last measurement
segment	The segment which from which the measurements are taken
vsualHelper	Obj helper to which the measurements are appended.
viewConfig	Configuration style of the drawn measurements

Definition at line 121 of file ObjVisualizationHelpers.cxx.

                                                                   {
        for (const auto& meas : segment.measurements()) {
            drawSpacePoint(gctx, *meas, segment.msSector(), visualHelper, viewConfig);
        }
    }

drawSegmentMeasurements() [2/2]

void MuonValR4::drawSegmentMeasurements	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewSensitive )

Draw all uncalibrated measurements associated to the segment.

Parameters

gctx	Geometry context needed to fetch the positions of the first & last measurement
segment	The segment which from which the measurements are taken
vsualHelper	Obj helper to which the measurements are appended.
viewConfig	Configuration style of the drawn measurements

Definition at line 112 of file ObjVisualizationHelpers.cxx.

                                                                   {
        std::vector<const xAOD::UncalibratedMeasurement*> assocMeas = collectMeasurements(segment, false);
        for (const xAOD::UncalibratedMeasurement* meas : assocMeas){
            drawMeasurement(gctx, meas, visualHelper, viewConfig);
        }
    }

drawSpacePoint() [1/2]

void MuonValR4::drawSpacePoint	(	const ActsTrk::GeometryContext &	gctx,
		const MuonR4::CalibratedSpacePoint &	spacePoint,
		const MuonGMR4::SpectrometerSector *	msSector,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewSensitive )

Draw a calibrated space point inside the obj file.

Ordinary measurements are forwarded to the uncalibrated case and the auxiliary beamspot constraint is handled extra

Parameters

gctx	Geometry context needed to fetch the positions of the surface
spacePoint	Reference to the space point to visualize
msSector	Pointer to the associated msSector (Fetch the transform for the auxiliaries)
vsualHelper	Obj helper to which the measurement is appended.
viewConfig	Configuration style of the drawn measurement

Definition at line 266 of file ObjVisualizationHelpers.cxx.

                                                          {
        if (spacePoint.type() != xAOD::UncalibMeasType::Other) {
            drawSpacePoint(gctx, *spacePoint.spacePoint(), visualHelper, viewConfig);
            return;
        }
        const Amg::Transform3D& locToGlob = msSector->localToGlobalTransform(gctx);
        if (spacePoint.isStraw()) {
              const double dR = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::etaCov)]);
              const double hZ = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::phiCov)]);
              auto bounds = std::make_unique<Acts::LineBounds>(dR, hZ);
              const Amg::Transform3D trf = locToGlob * Amg::getTranslate3D(spacePoint.localPosition());
              auto surface = Acts::Surface::makeShared<Acts::StrawSurface>(trf, std::move(bounds));    
              Acts::GeometryView3D::drawSurface(visualHelper, *surface, gctx.context());    
        } else {
            const double dX = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::phiCov)]);
            const double dY = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::etaCov)]);
            auto bounds = std::make_unique<Acts::RectangleBounds>(dX, dY);
            const Acts::Transform3 trf = locToGlob * Amg::getTranslate3D(spacePoint.localPosition());
            auto surf = Acts::Surface::makeShared<Acts::PlaneSurface>(trf, std::move(bounds));
            Acts::GeometryView3D::drawSurface(visualHelper, *surf, gctx.context());
        }
    }

drawSpacePoint() [2/2]

void MuonValR4::drawSpacePoint	(	const ActsTrk::GeometryContext &	gctx,
		const MuonR4::SpacePoint &	spacePoint,
		Acts::ObjVisualization3D &	visualHelper,
		const Acts::ViewConfig &	viewConfig = Acts::s_viewSensitive )

Draw an uncalibrated space point inside the obj file.

A Spacepoint consisting of two 1D measurements is translated ino a small rectangle. Otherwise the request is forwarded to draw an uncalibrated measurement.

Parameters

gctx	Geometry context needed to fetch the positions of the surface
spacePoint	Reference to the space point to visualize
vsualHelper	Obj helper to which the measurement is appended.
viewConfig	Configuration style of the drawn measurement

Definition at line 248 of file ObjVisualizationHelpers.cxx.

                                                          {
        if (spacePoint.dimension() == 2 && !spacePoint.isStraw() &&
            spacePoint.primaryMeasurement() != spacePoint.secondaryMeasurement()) {
            const Amg::Transform3D& locToGlob =  spacePoint.msSector()->localToGlobalTransform(gctx);
            const double dX = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::phiCov)]);
            const double dY = std::sqrt(spacePoint.covariance()[Acts::toUnderlying(CovIdx::etaCov)]);
            auto bounds = std::make_unique<Acts::RectangleBounds>(dX, dY);
            const Acts::Transform3 trf = locToGlob * Amg::getTranslate3D(spacePoint.localPosition());
            auto surf = Acts::Surface::makeShared<Acts::PlaneSurface>(trf, std::move(bounds));
            Acts::GeometryView3D::drawSurface(visualHelper, *surf, gctx.context());
        } else {
            drawMeasurement(gctx, spacePoint.primaryMeasurement(), 
                            visualHelper, viewConfig);
        }
    }

ensureDirectory()

void MuonValR4::ensureDirectory

(

const std::string &

path

)

Ensures that the subdirectory in the path is created.

Parameters

path	Reference to the path from which the directory is to be craeted

Definition at line 17 of file FileHelpers.cxx.

                                                {
        const std::string dir = path.substr(0, path.rfind("/"));
        if (dir.rfind("/") != std::string::npos){
            ensureDirectory(dir);
        } else if (dir.empty()) {
            return;
        }
        if (!std::filesystem::is_directory(dir) && !std::filesystem::create_directory(dir)) {
            THROW_EXCEPTION("Failed to create "<<dir);
        }
    }

isInPattern()

bool MuonValR4::isInPattern	(	const SpacePoint *	sp,
		const StIndex	station,
		const GlobalPattern &	pattern )

Definition at line 32 of file MuonFastRecoTester.cxx.

                                                   {
        for (const SpacePoint* hit : pattern.hitsInStation(station)) {
            if (hit == sp) return true;
        }
        return false;
    };

isPrecHit()

template<class SpType>

bool MuonValR4::isPrecHit

(

const SpType &

sp

)

Define a spacepoint as precision hit if it's a Mdt or NSW eta hit.

Definition at line 48 of file MuonHoughTransformTester.cxx.

                                     {
        return sp.type() == xAOD::UncalibMeasType::MdtDriftCircleType ||
               sp.type() == xAOD::UncalibMeasType::MMClusterType ||
               (sp.type() == xAOD::UncalibMeasType::sTgcStripType && sp.measuresEta());
    }

isTruthMatched()

std::optional< std::size_t > MuonValR4::isTruthMatched	(	const SpacePoint *	sp,
		const TruthParticleMap &	truthHits )

Definition at line 19 of file MuonFastRecoTester.cxx.

                                                                                  {
        for (const xAOD::MuonSimHit* hit : getMatchingSimHits(std::vector<const SpacePoint*>{sp})) {
            std::size_t idx{0};
            for (const auto& [tp, truthHitSets] : truthHits) {
                for (const simHitSet& truthHitSet : truthHitSets) {
                    if (truthHitSet.count(hit)) return idx;
                }
                ++idx;
            }
        }
        return std::nullopt;
    };

nameBr()

std::string MuonValR4::nameBr ( Category cat, Status status, LayerIndex layer, bool isSmall )

inline

Definition at line 16 of file TrackSummaryModule.cxx.

                                                              {
        std::string lName = layerName(layer);
        lName[0] = std::tolower(lName[0]);
        return std::format("{:}{:}{:}{:}",
                    lName, (isSmall ? "Small" :"Large"),
                    HitSummary::toString(cat),
                    (status == Status::OnTrack ? std::string{"Hits"} 
                                               : HitSummary::toString(status) +"s"));
    }

removeNonAlphaNum()

std::string MuonValR4::removeNonAlphaNum

(

std::string

str

)

Removes all non-alpha numerical characters from a string.

Definition at line 10 of file FileHelpers.cxx.

                                                {
        str.erase(std::remove_if(str.begin(),str.end(),
                  [](const unsigned char c){
                    return !std::isalnum(c);
                   }), str.end());
        return str; 
     }

seedColorIdx()

int MuonValR4::seedColorIdx

(

std::size_t

iSeed

)

Definition at line 80 of file TrackVisualizationTool.cxx.

                                     {
        // Golden ratio hue stepping -> good spread even for many seeds
        constexpr double phi = 0.6180339887498949;
        const double h = 360 * std::fmod(0.13 + phi * double(iSeed), 1.0);  // [0,1)
        constexpr double s = 0.75;
        constexpr double v = 0.95;
 
        float r=0.f, g=0.f, b=0.f;
        TColor::HLS2RGB(h, s, v, r, g, b);
        return TColor::GetColor(r, g, b);
    }

Variable Documentation

fullFilling

int MuonValR4::fullFilling = 1001

constexpr

Definition at line 24 of file VisualizationHelpers.h.

hatchedFilling

int MuonValR4::hatchedFilling = 3344

constexpr

Definition at line 25 of file VisualizationHelpers.h.

hollowFilling

int MuonValR4::hollowFilling = 0

constexpr

Filling codes for hollow / fullFilling / hatched filling.

Definition at line 23 of file VisualizationHelpers.h.

objViewEta

int MuonValR4::objViewEta = Acts::toUnderlying(MuonR4::SegmentFit::AxisDefs::etaCov)

constexpr

ObjectView.

Definition at line 28 of file VisualizationHelpers.h.

objViewPhi

int MuonValR4::objViewPhi = Acts::toUnderlying(MuonR4::SegmentFit::AxisDefs::phiCov)

constexpr

Definition at line 29 of file VisualizationHelpers.h.