MuonR4::SegmentFit Namespace Reference

Classes
class	MdtSegmentSeedGenerator
	Helper class to generate valid seeds for the segment fit. More...
class	SegmentAmbiSolver
	The SegmentAmbiSolver removes ambiguities between segment candidates from the fit. More...
class	SegmentLineFitter
	The SegmentLineFitter is a standalone module to fit a straight line to calibrated muon space points. More...

Typedefs
using	SeedingAux = SpacePoint::SeedingAux
	Abrivation of the CompSpacePointAuxiliaries.
using	ParamDefs = SeedingAux::FitParIndex
	Use the same parameter indices as used by the CompSpacePointAuxiliaries.
using	Line_t = SeedingAux::Line_t
	Abrivation of the line with partial derivatives.
using	AxisDefs = SpacePoint::CovIdx
	Use the same mapping of the covariance space indicies as used by the SpacePoint.
using	Parameters = Acts::Experimental::CompositeSpacePointLineFitter::ParamVec_t
using	Covariance = Acts::Experimental::CompositeSpacePointLineFitter::CovMat_t
using	HitVec = SpacePointPerLayerSplitter::HitVec
using	HitLayerVec = SpacePointPerLayerSplitter::HitLayVec
using	SegmentVec = SegmentAmbiSolver::SegmentVec
using	Hit_t = SegmentLineFitter::Hit_t
using	HitVec_t = SegmentLineFitter::HitVec_t
using	Result_t = SegmentLineFitter::Result_t

Functions
std::pair< Amg::Vector3D, Amg::Vector3D >	makeLine (const Parameters &pars)
	Returns the parsed parameters into an Eigen line parametrization.
std::string	makeLabel (const Parameters &pars)
	Dumps the parameters into a string in the form of TLatex.
std::string	toString (const Parameters &pars)
	Dumps the parameters into a string with labels in front of each number.
std::string	toString (const ParamDefs par)
	Returns the parameter label.
Parameters	localSegmentPars (const xAOD::MuonSegment &seg)
	Returns the localSegPars decoration from a xAODMuon::Segment.
Parameters	localSegmentPars (const ActsTrk::GeometryContext &gctx, const Segment &segment)
	Returns the local segment parameters from a segment object.
Acts::BoundTrackParameters	boundSegmentPars (const MuonGMR4::MuonDetectorManager &detMgr, const xAOD::MuonSegment &segment, std::optional< Acts::BoundMatrix > cov=std::nullopt, Acts::ParticleHypothesis hypot=Acts::ParticleHypothesis::muon())
	Returns the segment parameters as boundTrackParameters.
Acts::BoundTrackParameters	boundSegmentPars (const ActsTrk::GeometryContext &gctx, const Segment &segment, const Acts::ParticleHypothesis hypot=Acts::ParticleHypothesis::muon())
	Returns the segment parameters as boundTrackParameters.
Muon::MdtDriftCircleStatus	dcStatus (const SpacePoint &dc)
bool	isGoodDC (const SpacePoint &dc)
	Returns whether the Mdt measurement has a valid space point.
bool	moveToNextHit (const HitVec &hits, std::size_t &hitIdx)
	Move to the next space point with valid drift radius.
bool	firstGoodHit (const HitVec &hits, std::size_t &hitIdx)
	Find the first good hit in a layer.

Variables
constexpr auto	covIdx = Acts::toUnderlying(AxisDefs::etaCov)

Typedef Documentation

AxisDefs

using MuonR4::SegmentFit::AxisDefs = SpacePoint::CovIdx

Use the same mapping of the covariance space indicies as used by the SpacePoint.

Definition at line 43 of file MuonHoughDefs.h.

Covariance

using MuonR4::SegmentFit::Covariance = Acts::Experimental::CompositeSpacePointLineFitter::CovMat_t

Definition at line 47 of file MuonHoughDefs.h.

Hit_t

using MuonR4::SegmentFit::Hit_t = SegmentLineFitter::Hit_t

Definition at line 31 of file SegmentLineFitter.cxx.

HitLayerVec

using MuonR4::SegmentFit::HitLayerVec = SpacePointPerLayerSplitter::HitLayVec

Definition at line 21 of file MdtSegmentSeedGenerator.cxx.

HitVec

using MuonR4::SegmentFit::HitVec = SpacePointPerLayerSplitter::HitVec

Definition at line 20 of file MdtSegmentSeedGenerator.cxx.

HitVec_t

using MuonR4::SegmentFit::HitVec_t = SegmentLineFitter::HitVec_t

Definition at line 32 of file SegmentLineFitter.cxx.

Line_t

using MuonR4::SegmentFit::Line_t = SeedingAux::Line_t

Abrivation of the line with partial derivatives.

Definition at line 40 of file MuonHoughDefs.h.

ParamDefs

using MuonR4::SegmentFit::ParamDefs = SeedingAux::FitParIndex

Use the same parameter indices as used by the CompSpacePointAuxiliaries.

Definition at line 38 of file MuonHoughDefs.h.

Parameters

using MuonR4::SegmentFit::Parameters = Acts::Experimental::CompositeSpacePointLineFitter::ParamVec_t

Definition at line 46 of file MuonHoughDefs.h.

Result_t

using MuonR4::SegmentFit::Result_t = SegmentLineFitter::Result_t

Definition at line 33 of file SegmentLineFitter.cxx.

SeedingAux

using MuonR4::SegmentFit::SeedingAux = SpacePoint::SeedingAux

Abrivation of the CompSpacePointAuxiliaries.

Definition at line 36 of file MuonHoughDefs.h.

SegmentVec

using MuonR4::SegmentFit::SegmentVec = SegmentAmbiSolver::SegmentVec

Definition at line 8 of file SegmentAmbiSolver.cxx.

Function Documentation

boundSegmentPars() [1/2]

Acts::BoundTrackParameters MuonR4::SegmentFit::boundSegmentPars	(	const ActsTrk::GeometryContext &	gctx,
		const Segment &	segment,
		const Acts::ParticleHypothesis	hypot = Acts::ParticleHypothesis::muon() )

Returns the segment parameters as boundTrackParameters.

The position is expressed locally on the sector surface & the direction in the global frame

Definition at line 112 of file SegmentFitterEventData.cxx.

                                                                                        {
            const auto& surface = segment.msSector()->surface();
 
            const Amg::Vector3D locPos = surface.transform(gctx.context()).inverse() * 
                                         segment.position();
             Acts::BoundVector boundPars{};
            boundPars[Acts::eBoundLoc0] = locPos.x();
            boundPars[Acts::eBoundLoc1] = locPos.y();
            boundPars[Acts::eBoundPhi] = segment.direction().phi();
            boundPars[Acts::eBoundTheta] = segment.direction().theta();
            boundPars[Acts::eBoundQOverP] = straightQoverP;
            boundPars[Acts::eBoundTime] = ActsTrk::timeToActs(segment.position().mag() / Gaudi::Units::c_light + 
                                                              segment.segementT0());
            Acts::BoundMatrix cov{Acts::BoundMatrix::Identity()};
 
            return Acts::BoundTrackParameters{surface.getSharedPtr(), std::move(boundPars),
                                              cov, hypot};
        }

boundSegmentPars() [2/2]

Acts::BoundTrackParameters MuonR4::SegmentFit::boundSegmentPars	(	const MuonGMR4::MuonDetectorManager &	detMgr,
		const xAOD::MuonSegment &	segment,
		std::optional< Acts::BoundMatrix >	cov = std::nullopt,
		Acts::ParticleHypothesis	hypot = Acts::ParticleHypothesis::muon() )

Returns the segment parameters as boundTrackParameters.

The position is expressed locally on the sector surface & the direction in the global frame

Parameters

detMgr	Detector manager to pick up the proper sector object
segment	Reference to the segment of interest
cov	Uncertainty on the parsed parameters
hypot	The particle hypothesis to plugin (Muon by default)

Definition at line 85 of file SegmentFitterEventData.cxx.

                                                                                  {
            
            const auto* msSector = detMgr.getSectorEnvelope(segment.chamberIndex(), 
                                                            segment.sector(),
                                                            segment.etaIndex());
            const Acts::Surface& surface = msSector->surface();
 
            const auto locSegPars = localSegmentPars(segment);
 
            const Amg::Vector3D globDir = segment.direction();
 
            
            Acts::BoundVector boundPars{};
            boundPars[Acts::eBoundLoc0] = locSegPars[toUnderlying(ParamDefs::x0)];
            boundPars[Acts::eBoundLoc1] = locSegPars[toUnderlying(ParamDefs::y0)];
            boundPars[Acts::eBoundPhi] = globDir.phi();
            boundPars[Acts::eBoundTheta] = globDir.theta();
            boundPars[Acts::eBoundQOverP] = straightQoverP;
            boundPars[Acts::eBoundTime] = ActsTrk::timeToActs(segment.position().mag() / Gaudi::Units::c_light + 
                                                              segment.t0());
 
            return Acts::BoundTrackParameters{surface.getSharedPtr(), std::move(boundPars),
                                              cov, hypot};
        }

dcStatus()

Muon::MdtDriftCircleStatus MuonR4::SegmentFit::dcStatus ( const SpacePoint & dc )

inline

Definition at line 25 of file MdtSegmentSeedGenerator.cxx.

                                                                   {
        const xAOD::UncalibratedMeasurement* prd = dc.primaryMeasurement();
        if (prd->type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            return static_cast<const xAOD::MdtDriftCircle*>(prd)->status();
        }
        return Muon::MdtDriftCircleStatus::MdtStatusUnDefined;
    }

firstGoodHit()

bool MuonR4::SegmentFit::firstGoodHit ( const HitVec & hits, std::size_t & hitIdx )

inline

Find the first good hit in a layer.

Parameters

hits	List of hits in a particular tube layer
hitIdx	Index of the current hit inside this list

Definition at line 47 of file MdtSegmentSeedGenerator.cxx.

                                                                    {
        hitIdx = 0;
        return isGoodDC(*hits[hitIdx]) || moveToNextHit(hits, hitIdx);
    }

isGoodDC()

bool MuonR4::SegmentFit::isGoodDC ( const SpacePoint & dc )

inline

Returns whether the Mdt measurement has a valid space point.

Definition at line 33 of file MdtSegmentSeedGenerator.cxx.

                                               {
        return dcStatus(dc) == Muon::MdtDriftCircleStatus::MdtStatusDriftTime;
    } 

localSegmentPars() [1/2]

Parameters MuonR4::SegmentFit::localSegmentPars	(	const ActsTrk::GeometryContext &	gctx,
		const Segment &	segment )

Returns the local segment parameters from a segment object.

Parameters

gctx	Geometry context storing the local -> global transformation
segment	Reference to the segment

Definition at line 50 of file SegmentFitterEventData.cxx.

                                                            {
            Parameters pars{};
            const Amg::Transform3D globToLoc = segment.msSector()->globalToLocalTrans(gctx);
            const Amg::Vector3D locPos = globToLoc * segment.position();
            const Amg::Vector3D locDir = globToLoc.linear() * segment.direction();
            pars[toUnderlying(ParamDefs::x0)] = locPos.x();
            pars[toUnderlying(ParamDefs::y0)] = locPos.y();
            pars[toUnderlying(ParamDefs::theta)] = locDir.theta();
            pars[toUnderlying(ParamDefs::phi)] = locDir.phi();
            pars[toUnderlying(ParamDefs::t0)] = segment.segementT0();
            return pars;
        }

localSegmentPars() [2/2]

Parameters MuonR4::SegmentFit::localSegmentPars

(

const xAOD::MuonSegment &

seg

)

Returns the localSegPars decoration from a xAODMuon::Segment.

Definition at line 42 of file SegmentFitterEventData.cxx.

                                                                {
            static const SG::Accessor<xAOD::MeasVector<toUnderlying(ParamDefs::nPars)>> acc{"localSegPars"};
            Parameters segPars{};
            for (std::size_t p =0 ; p < segPars.size(); ++p) {
                segPars[p] = acc(seg)[p];
            }
            return segPars;
        }

makeLabel()

std::string MuonR4::SegmentFit::makeLabel

(

const Parameters &

pars

)

Dumps the parameters into a string in the form of TLatex.

Distances are expressed in [mm], angles in [deg] and time in [ns]

Parameters

pars	Reference to the parameters to dump

Definition at line 64 of file SegmentFitterEventData.cxx.

                                                   {
            std::stringstream sstr{};
            sstr<<std::format("x_{{0}}={:.2f}", pars[toUnderlying(ParamDefs::x0)])<<", ";
            sstr<<std::format("y_{{0}}={:.2f}", pars[toUnderlying(ParamDefs::y0)])<<", ";
            sstr<<std::format("#theta={:.2f}^{{#circ}}", pars[toUnderlying(ParamDefs::theta)] / Gaudi::Units::deg )<<", ";
            sstr<<std::format("#phi={:.2f}^{{#circ}}", pars[toUnderlying(ParamDefs::phi)] / Gaudi::Units::deg)<<", ";
            sstr<<std::format("t_{{0}}={:.1f}", pars[toUnderlying(ParamDefs::t0)]);
            return sstr.str();
        }

makeLine()

std::pair< Amg::Vector3D, Amg::Vector3D > MuonR4::SegmentFit::makeLine

(

const Parameters &

pars

)

Returns the parsed parameters into an Eigen line parametrization.

The first operand is the position. The other is the direction.

Definition at line 35 of file SegmentFitterEventData.cxx.

                                                                           {
            using enum ParamDefs;
            return std::make_pair(Amg::Vector3D(pars[toUnderlying(x0)], 
                                                pars[toUnderlying(y0)],0.),
                                  Amg::dirFromAngles(pars[toUnderlying(phi)],
                                                     pars[toUnderlying(theta)]));
        }

moveToNextHit()

bool MuonR4::SegmentFit::moveToNextHit ( const HitVec & hits, std::size_t & hitIdx )

inline

Move to the next space point with valid drift radius.

Parameters

hits	List of hits in a particular tube layer
hitIdx	Index of the current hit inside this list

Definition at line 39 of file MdtSegmentSeedGenerator.cxx.

                                                                     {
        while(++hitIdx < hits.size() && !isGoodDC(*hits[hitIdx])) {
        }
        return hitIdx < hits.size() && isGoodDC(*hits[hitIdx]);
    }

toString() [1/2]

std::string MuonR4::SegmentFit::toString

(

const ParamDefs

par

)

Returns the parameter label.

Parameters

par	Parameter of interest

Definition at line 82 of file SegmentFitterEventData.cxx.

                                              {
           return SeedingAux::parName(a);
        }

toString() [2/2]

std::string MuonR4::SegmentFit::toString

(

const Parameters &

pars

)

Dumps the parameters into a string with labels in front of each number.

Distances are expressed in [mm], angles in [deg] and time in [ns]

Parameters

pars	Reference to the parameters to dump

Definition at line 73 of file SegmentFitterEventData.cxx.

                                                   {
            std::stringstream sstr{};
            sstr<< std::format("{}={:.2f}, ",toString(ParamDefs::x0), pars[toUnderlying(ParamDefs::x0)]);
            sstr<< std::format("{}={:.2f}, ",toString(ParamDefs::y0), pars[toUnderlying(ParamDefs::y0)]);
            sstr<< std::format("{}={:.2f}, ",toString(ParamDefs::theta), pars[toUnderlying(ParamDefs::theta)]/Gaudi::Units::deg);
            sstr<< std::format("{}={:.2f}, ",toString(ParamDefs::phi),  pars[toUnderlying(ParamDefs::phi)]/Gaudi::Units::deg);
            sstr<< std::format("{}={:.2f}",toString(ParamDefs::t0), pars[toUnderlying(ParamDefs::t0)]);
            return sstr.str();
        }

Variable Documentation

covIdx

auto MuonR4::SegmentFit::covIdx = Acts::toUnderlying(AxisDefs::etaCov)

constexpr

Definition at line 22 of file MdtSegmentSeedGenerator.cxx.