MuonR4::SegmentFit Namespace Reference

Classes
struct	SeederStateBase
	Helper struct to delegate the EDM interactions with the space point container during the seeding. More...
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.
std::optional< Covariance >	localSegmentCov (const xAOD::MuonSegment &seg)
	Returns the localCovariance decoration from a xAOD::MuonSegment.
Parameters	localSegmentPars (const ActsTrk::GeometryContext &gctx, const Segment &segment)
	Returns the local segment parameters from a segment object.
Parameters	localSegmentPars (const Acts::GeometryContext &tgContext, const Segment &segment)
	Returns the localSegPars decoration from a xAODMuon::Segment.
Acts::BoundTrackParameters	boundSegmentPars (const ActsTrk::GeometryContext &gctx, const MuonGMR4::MuonDetectorManager &detMgr, const xAOD::MuonSegment &segment, const Acts::ParticleHypothesis hypot=Acts::ParticleHypothesis::muon())
	Returns the segment parameters as boundTrackParameters.
Acts::BoundTrackParameters	boundSegmentPars (const Acts::GeometryContext &tgContext, const MuonGMR4::MuonDetectorManager &detMgr, const xAOD::MuonSegment &segment, const 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.
Acts::BoundTrackParameters	boundSegmentPars (const Acts::GeometryContext &tgContext, const Segment &segment, const Acts::ParticleHypothesis hypot=Acts::ParticleHypothesis::muon())
	Returns the segment parameters as boundTrackParameters.
std::optional< Acts::BoundMatrix >	translateCovariance (const Parameters &locSegPars, std::optional< Covariance > &&localCov, const Amg::Transform3D &localToGlobal)

Variables
constexpr std::size_t	N = Acts::toUnderlying(ParamDefs::nPars)

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 33 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 34 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 35 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/4]

Acts::BoundTrackParameters MuonR4::SegmentFit::boundSegmentPars	(	const Acts::GeometryContext &	tgContext,
		const MuonGMR4::MuonDetectorManager &	detMgr,
		const xAOD::MuonSegment &	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

Parameters

gctx	The Geometrycontext to translate the angular jacobian of theta & phi
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 139 of file SegmentFitterEventData.cxx.

                                                                                        {
            return boundSegmentPars(*tgContext.get<const ActsTrk::GeometryContext*>(),
                                     detMgr, segment, hypot);
        }

boundSegmentPars() [2/4]

Acts::BoundTrackParameters MuonR4::SegmentFit::boundSegmentPars	(	const Acts::GeometryContext &	tgContext,
		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

Parameters

gctx	The Geometrycontext to translate the angular jacobian of theta & phi
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)

boundSegmentPars() [3/4]

Acts::BoundTrackParameters MuonR4::SegmentFit::boundSegmentPars	(	const ActsTrk::GeometryContext &	gctx,
		const MuonGMR4::MuonDetectorManager &	detMgr,
		const xAOD::MuonSegment &	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

Parameters

gctx	The Geometrycontext to translate the angular jacobian of theta & phi
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 146 of file SegmentFitterEventData.cxx.

                                                                                        {
            
            const auto* msSector = detMgr.getSectorEnvelope(segment.chamberIndex(), 
                                                            segment.sector(),
                                                            segment.etaIndex());
 
            const Parameters locSegPars = localSegmentPars(segment);
            const Amg::Vector3D globDir = segment.direction();
            
            Acts::BoundVector boundPars{};
            boundPars[Acts::eBoundLoc0] = locSegPars[Acts::toUnderlying(ParamDefs::x0)];
            boundPars[Acts::eBoundLoc1] = locSegPars[Acts::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());
            
            // std::optional<Acts::BoundMatrix> cov = translateCovariance(localSegmentPars()
            return Acts::BoundTrackParameters{msSector->surface().getSharedPtr(), 
                                              std::move(boundPars),
                                              translateCovariance(locSegPars, localSegmentCov(segment),
                                                                  msSector->localToGlobalTransform(gctx)), hypot};
        }

boundSegmentPars() [4/4]

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.

Parameters

gctx	The geometry context needed to transform the global -> local parameters
segment	The segment for which the bound paramters shall be created
hypot	The particle hypothesis to plugin (Muon by default)

Definition at line 172 of file SegmentFitterEventData.cxx.

                                                                                        {
 
            const Amg::Vector3D locPos = segment.msSector()->globalToLocalTransform(gctx) * 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());
           
            return Acts::BoundTrackParameters{segment.msSector()->surface().getSharedPtr(), 
                                              std::move(boundPars),
                                              translateCovariance(localSegmentPars(gctx, segment),
                                                                  segment.covariance(),
                                                                 segment.msSector()->localToGlobalTransform(gctx)), hypot};
        }

localSegmentCov()

std::optional< Covariance > MuonR4::SegmentFit::localSegmentCov

(

const xAOD::MuonSegment &

seg

)

Returns the localCovariance decoration from a xAOD::MuonSegment.

Definition at line 84 of file SegmentFitterEventData.cxx.

                                                                            {
            static const xAOD::PosAccessor<Acts::sumUpToN(N)> acc{"localSegCov"};
            if (!acc.isAvailable(seg)) {
                return std::nullopt;
            }
            Covariance cov{Covariance::Zero()};
            const auto& covVec{acc(seg)};
            for (std::size_t i = 0 ; i < covVec.size(); ++i) {
                const auto [p, p1] = Acts::symMatIndices<N>(i);
                cov(p,p1) = cov(p1,p) = covVec[i];
            }
            return cov;
        }

localSegmentPars() [1/3]

Parameters MuonR4::SegmentFit::localSegmentPars	(	const Acts::GeometryContext &	tgContext,
		const Segment &	segment )

Returns the localSegPars decoration from a xAODMuon::Segment.

Definition at line 98 of file SegmentFitterEventData.cxx.

                                                            {
            return localSegmentPars(*tgContext.get<const ActsTrk::GeometryContext*>(), segment);
        }

localSegmentPars() [2/3]

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 103 of file SegmentFitterEventData.cxx.

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

localSegmentPars() [3/3]

Parameters MuonR4::SegmentFit::localSegmentPars

(

const xAOD::MuonSegment &

seg

)

Returns the localSegPars decoration from a xAODMuon::Segment.

Definition at line 76 of file SegmentFitterEventData.cxx.

                                                                {
            static const xAOD::PosAccessor<N> acc{"localSegPars"};
            Parameters segPars{};
            for (std::size_t p =0 ; p < N; ++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 117 of file SegmentFitterEventData.cxx.

                                                   {
            std::stringstream sstr{};
            sstr<<std::format("x_{{0}}={:.2f}", pars[Acts::toUnderlying(ParamDefs::x0)])<<", ";
            sstr<<std::format("y_{{0}}={:.2f}", pars[Acts::toUnderlying(ParamDefs::y0)])<<", ";
            sstr<<std::format("#theta={:.2f}^{{#circ}}",inDeg(pars[Acts::toUnderlying(ParamDefs::theta)]))<<", ";
            sstr<<std::format("#phi={:.2f}^{{#circ}}",  inDeg(pars[Acts::toUnderlying(ParamDefs::phi)]))<<", ";
            sstr<<std::format("t_{{0}}={:.1f}", pars[Acts::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 69 of file SegmentFitterEventData.cxx.

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

toString() [1/2]

std::string MuonR4::SegmentFit::toString

(

const ParamDefs

par

)

Returns the parameter label.

Parameters

par	Parameter of interest

Definition at line 135 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 126 of file SegmentFitterEventData.cxx.

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

translateCovariance()

std::optional< Acts::BoundMatrix > MuonR4::SegmentFit::translateCovariance ( const Parameters & locSegPars, std::optional< Covariance > && localCov, const Amg::Transform3D & localToGlobal )

inline

Definition at line 40 of file SegmentFitterEventData.cxx.

                                                                     {
            if (!localCov) {
                return std::nullopt;
            }
            const SeedingAux::Line_t line{locSegPars};
 
            Acts::Matrix<3,2> basisTrf{};
            basisTrf.block<3,1>(0,1) = line.gradient(SeedingAux::Line_t::ParIndex::theta);
            basisTrf.block<3,1>(0,0) = line.gradient(SeedingAux::Line_t::ParIndex::phi);
 
            BoundMatrix jacobian{BoundMatrix::Identity()};
            jacobian.block<2,2>(Acts::eBoundPhi, Acts::eBoundPhi) = basisTrf.transpose() * 
                                                                    localToGlobal.linear() * 
                                                                    basisTrf;
            BoundMatrix cov{BoundMatrix::Identity()};
            cov.block<N,N>(0,0) = std::move(*localCov);
            BoundMatrix translator{BoundMatrix::Zero()};
            translator( Acts::toUnderlying(ParamDefs::x0), Acts::eBoundLoc0) =
            translator( Acts::toUnderlying(ParamDefs::y0), Acts::eBoundLoc1) =
            translator( Acts::toUnderlying(ParamDefs::theta), Acts::eBoundTheta) =
            translator( Acts::toUnderlying(ParamDefs::phi), Acts::eBoundPhi) =
            translator( Acts::toUnderlying(ParamDefs::t0), Acts::eBoundTime) =
            translator( Acts::toUnderlying(ParamDefs::nPars), Acts::eBoundQOverP) = 1.;
            translator = jacobian * translator;
            return translator.transpose() * cov * translator;
        }

Variable Documentation

N

std::size_t MuonR4::SegmentFit::N = Acts::toUnderlying(ParamDefs::nPars)

constexpr

Definition at line 37 of file SegmentFitterEventData.cxx.