MuonCombinedR4 Namespace Reference

Classes
class	BeamSpotPreparatorAlg
	Data preparation algorithm to convert the beamspot position into an auxiliary measurement which can be used in the combined muon fit as an extra constaint at the vertex. More...
class	CombinedFitAlg
class	CombinedStacoAlg
	Prototype to combine ID + MS tracks using the statistical combination The ID + MS momentum are combined using the inverse of the respective q/p covariance values of the two tracks. More...
class	InDetTrackSelectionAlg
	Algorithm to select ID / ITk track candidates which may be suitable for the combined muon reconstruction chain. More...
class	MuonCreatorAlg
	Algorithm to create the xAOD::Muon analysis objects from the various muon reconstruction chains. More...
class	SegmentTaggingAlg
class	StandaloneMuonTagAlg
	Algorithm to transform the produced MS tracks into a muon tag container and to associate the segments with the MuonTag. More...

Functions
std::optional< Acts::BoundTrackParameters >	makeDiffParameters (const Acts::GeometryContext &tgContext, const Acts::BoundTrackParameters &idParameters, const Acts::BoundTrackParameters &msParameters, const Acts::Logger &logger, const double boundTolerance=Acts::UnitConstants::km)
	Calculates the difference parameters between the ID and the MS If the parameters are expressed on different surfaces and the MS parameters are close to the boundary, then the MS parameters are linearliy extrapolated to the ID surface.
double	longitudinalParam (const Acts::BoundTrackParameters &pars, const Acts::Logger &logger)
	Returns the longitudinal local track parameter which is defined as.
double	localPolarAngle (const Acts::BoundTrackParameters &pars, const Acts::Logger &logger)
	Returns the local angular polar angle of the track parameter.

Function Documentation

localPolarAngle()

double MuonCombinedR4::localPolarAngle	(	const Acts::BoundTrackParameters &	pars,
		const Acts::Logger &	logger )

Returns the local angular polar angle of the track parameter.

Parameters

pars	Reference to the parameters of interest
logger	The logger instance for printing the debug message
pars	Reference to the parameters of interest

Definition at line 128 of file TrackMatchingUtils.cxx.

                                                     {
       switch (pars.referenceSurface().type()) {
            using enum Acts::Surface::SurfaceType;
            case Disc:
                return pars.get<Acts::eBoundLoc1>();
            case Cylinder: {
                using enum Acts::CylinderBounds::BoundValues;
                const double R = static_cast<const Acts::CylinderBounds&>(pars.referenceSurface().bounds()).get(eR);
                return pars.get<Acts::eBoundLoc0>() / R;
            } default:
                ACTS_WARNING(__func__<<"() "<<__LINE__<<" Surface type "<<pars.referenceSurface().type()
                                <<" is not implemented");
                break;
        }
        return 360._degree;
    }

longitudinalParam()

double MuonCombinedR4::longitudinalParam	(	const Acts::BoundTrackParameters &	pars,
		const Acts::Logger &	logger )

Returns the longitudinal local track parameter which is defined as.

• radial parameter in case of discs
• displacement along the cylinder axis for cylinders

  Parameters

  pars	Reference to the parameters of interest
  logger	The logger instance for printing the debug message

Definition at line 111 of file TrackMatchingUtils.cxx.

                                                       {
               switch (pars.referenceSurface().type()) {
            using enum Acts::Surface::SurfaceType;
            case Disc:
                return pars.get<Acts::eBoundLoc0>();
            case Cylinder:
                return pars.get<Acts::eBoundLoc1>();
            default:
                ACTS_WARNING(__func__<<"() "<<__LINE__<<" Surface type "<<pars.referenceSurface().type()
                                <<" is not implemented");
                break;
        }
        return -1._km;
    }

makeDiffParameters()

std::optional< Acts::BoundTrackParameters > MuonCombinedR4::makeDiffParameters	(	const Acts::GeometryContext &	tgContext,
		const Acts::BoundTrackParameters &	idParameters,
		const Acts::BoundTrackParameters &	msParameters,
		const Acts::Logger &	logger,
		const double	boundTolerance = Acts::UnitConstants::km )

Calculates the difference parameters between the ID and the MS If the parameters are expressed on different surfaces and the MS parameters are close to the boundary, then the MS parameters are linearliy extrapolated to the ID surface.

If extrapolation fails or the boundary conditions are not fullfilled a std::nullopt is returned.

Parameters

tgContext	The geometry context to propagated the MS track parameters to the ID surface if needed
idParameters	The parameters from the Inner Detector to match
msParameters	The parameters from the MuonSpectrometer to match
logger	The logger instance for printing the debug message
boundTolerance	The maximum distance that the MS parameters may be apart from the surface boundary to be extrapolated

Propagate the MS parameters to the ID parameters

Update the difference parameters

Update the MS covariance

Map the loc1 parameter to [-pi, pi]

Map the loc0 parameter to [-pi, pi] x R

Definition at line 20 of file TrackMatchingUtils.cxx.

                                                        {
        
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Calculate difference parameters between \n"
                    <<idParameters<<"\n\n and \n\n"<<msParameters);
        Acts::BoundVector diffPars = msParameters.parameters() -idParameters.parameters();
       
        const Acts::Surface& idSurf{idParameters.referenceSurface()};
        const Acts::Surface& msSurf{msParameters.referenceSurface()};
        
        std::optional<Acts::BoundMatrix> msCov{msParameters.covariance()};
        const std::optional<Acts::BoundMatrix>& idCov{idParameters.covariance()};
 
        if (idSurf.geometryId() != msSurf.geometryId() || 
            (idSurf.geometryId() == Acts::GeometryIdentifier{} && 
             idSurf.getSharedPtr() != msSurf.getSharedPtr())) {
            switch (msSurf.type()) {
                using enum Acts::Surface::SurfaceType;
                case Disc:{
                    if (static_cast<const Acts::DiscBounds&>(msSurf.bounds()).rMax() - msParameters.get<Acts::eBoundLoc0>() > boundTolerance) {
                        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - The parameters are too far apart from the bounds ");
                        return std::nullopt;
                    }
                    break;
                } case Cylinder : {
                    using enum Acts::CylinderBounds::BoundValues;
                    if (static_cast<const Acts::CylinderBounds&>(msSurf.bounds()).get(eHalfLengthZ) -
                        std::abs(msParameters.get<Acts::eBoundLoc1>()) >  boundTolerance) {
                        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - The parameters are too far apart from the bounds ");
                        return std::nullopt;
                    }
                    break;
                } default: {
                    ACTS_WARNING(__func__<<"() "<<__LINE__<<" - Surface type "<<msSurf.type()<<" is not implemented");
                    break;
                }
            }
            const Acts::Intersection3D idIsect = idSurf.intersect(tgContext,
                                                                  msParameters.position(tgContext), 
                                                                  msParameters.direction(),
                                                                  Acts::BoundaryTolerance::Infinite()).closest();
            if (!idIsect.isValid()) {
                ACTS_WARNING(__func__<<"() "<<__LINE__<<" - The propgation of "<<msParameters<<" to "
                            <<idSurf.geometryId()<<", "<<idSurf.bounds()<<" failed.");
                return std::nullopt;
            }
            auto locPos = idSurf.globalToLocal(tgContext, idIsect.position(), msParameters.direction());
            if (!locPos.ok()) {
                ACTS_WARNING(__func__<<"() "<<__LINE__<<" - Local to global of  "<<Amg::toString(idIsect.position())
                    <<" is not on "<<idSurf.geometryId()<<", "<<idSurf.bounds()<<".");
                return std::nullopt;
            }
            diffPars[Acts::eBoundLoc0] = (*locPos)[Acts::eX] - idParameters.get<Acts::eBoundLoc0>();
            diffPars[Acts::eBoundLoc1] = (*locPos)[Acts::eY] - idParameters.get<Acts::eBoundLoc1>();
            if (msCov) {
                (*msCov) = idSurf.freeToBoundJacobian(tgContext, idIsect.position(), msParameters.direction()) *
                           msSurf.boundToFreeJacobian(tgContext, msParameters.position(tgContext), 
                                                       msParameters.direction())  * (*msCov);
            }
        }
        std::optional<Acts::BoundMatrix> diffCov{};
        if (idCov || msCov) {
            diffCov = idCov.value_or(Acts::BoundMatrix::Zero()) +
                      msCov.value_or(Acts::BoundMatrix::Zero());
        }
        if (idSurf.type() == Acts::Surface::SurfaceType::Disc) {
            diffPars[Acts::eBoundLoc1] = deltaPhi(msParameters.get<Acts::eBoundLoc1>(), 
                                                  idParameters.get<Acts::eBoundLoc1>());
        } else if (idSurf.type() == Acts::Surface::SurfaceType::Cylinder) {
            using enum Acts::CylinderBounds::BoundValues;
            const double R = static_cast<const Acts::CylinderBounds&>(idSurf.bounds()).get(eR);
            diffPars[Acts::eBoundLoc0] = deltaPhi(msParameters.get<Acts::eBoundLoc0>() / R, 
                                                  idParameters.get<Acts::eBoundLoc0>() / R) * R;
        }
        Acts::BoundTrackParameters retPars{idSurf.getSharedPtr(),
                                           /*Ensure that theta remains positive otherwise 
                                             the constructor flips the direction */
                                           Acts::copySign(diffPars, diffPars[Acts::eBoundTheta]),  
                                            diffCov, msParameters.particleHypothesis()};
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Successfully created \n"<<retPars);
        return retPars;
    }