MuonR4 Namespace Reference

This header ties the generic definitions in this package. More...

Namespaces
	CombinatorialSeedSolver
	HoughHelpers
	SegmentFit
	SegmentFitHelpers

Classes
class	BucketDumperAlg
class	CalibratedSpacePoint
	The calibrated Space point is created during the calibration process. More...
class	CombinatorialNSWSeedFinderAlg
class	EtaHoughTransformAlg
	Algorithm to handle the eta hough transform. More...
struct	HoughEventData_impl
	Templated event data class for the phase-2 muon hough transform. More...
class	HoughMaximum
	Data class to represent an eta maximum in hough space. More...
class	ISegmentSelectionTool
class	ISpacePointCalibrator
	Interface class to refine the space point calibration with an external seed. More...
class	MdtDigitizationTool
class	MdtMeasViewAlg
class	MdtSegmentFitter
class	MdtSegmentSeedGenerator
	Helper class to generate valid seeds for the segment fit. More...
class	MeasurementMarkerAlg
	Algorithm that marks the uncalibrated measurements making up a segment, where the segment passes an arbitrary selection requirement. More...
class	MlHitDumperAlg
class	MM_DigitizationTool
class	MmFastDigiTool
class	MSTrackFindingAlg
class	MsTrackSeed
class	MsTrackSeeder
	Helper class to group muon sgements that may belong to a muon trajectory. More...
class	MuonDigitizationTool
	Barebone implementation of the I/O infrastructure for all MuonDigitizationTools. More...
class	PatternCnvAlg
	The MuonPatternCnvAlg converts the SegmentSeeds produced by the R4 pattern recognition chain into the segment seeds that can be consumed by the legacy muon segment maker. More...
class	PhiHoughTransformAlg
	Algorithm to handle the phi hough transform. More...
class	PrdMultiTruthMaker
	The PrdMultiTruthMaker translates the UncalibratedMeasurementContainers of a given MS technology to PRD_MultiTruthCollections, which are later needed for a TruthParticle <-> SDO matching. More...
class	PrepDataToSimHitAssocAlg
	The PrepDataToSimHitAssocAlg matches the uncalibrated measurements to the MuonSimHits or to the MuonSDO objects. More...
class	RecoSegToTruthAssocAlg
	Algorithm to match the reconstructed muon segment with the truth segment & with the truth particle. More...
class	RpcClusteringAlg
class	RpcFastDigiTool
class	RpcMeasViewAlg
class	RpcRdoToRpcPrepDataTool
class	SdoMultiTruthMaker
	The SdoMuliTruthMaker translates the HepMCParticle links associated with the SDO into a PRD_MultiTruthCollection. More...
class	Segment
	Placeholder for what will later be the muon segment EDM representation. More...
class	SegmentActsRefitAlg
class	SegmentAmbiSolver
class	SegmentFitParDecorAlg
	Algorithm to decorate the segment fit parameters in the chamber's frame onto the xAOD::MuonSegment Additionally, the ElementLinks to the associated measurements are decorated. More...
struct	SegmentFitResult
class	SegmentFittingAlg
	Algorithm to handle segment fits More...
class	SegmentMarkerAlg
class	SegmentSeed
	Representation of a segment seed (a fully processed hough maximum) produced by the hough transform. More...
class	SegmentSelectionTool
class	SegmentViewAlg
class	SpacePoint
	The muon space point is the combination of two uncalibrated measurements one of them measures the eta and the other the phi coordinate. More...
class	SpacePointBucket
	: The muon space point bucket represents a collection of points that will bre processed together in the pattern seeding. More...
class	SpacePointCalibrator
class	SpacePointCsvDumperAlg
class	SpacePointMakerAlg
class	SpacePointPerLayerSorter
	The SpacePointPerLayerSorter sort two given space points by their layer Identifier. More...
class	SpacePointPerLayerSplitter
	The SpacePointPerLayerSplitter takes a set of spacepoints already sorted by layer Identifier (see MuonSpacePoint/SpacePointPerLayerSorter.h) and splits them into two sets of hits, one for MDT hits and the other one for strip detector hits. More...
class	SPIdDumperAlg
class	sTgcDigitizationTool
class	sTgcFastDigiTool
class	sTgcMeasViewAlg
class	TgcFastDigiTool
class	TrackToTruthPartAssocAlg
	The TrackToTruthPartAssocAlg matches the reconstructed tracks to truth muons. More...
class	TrkSegmentCnvAlg
	The TrkSegmentCnvAlg converts the SegmentSeeds produced by the R4 pattern recognition chain into the segment seeds that can be consumed by the legacy muon segment maker. More...
class	TruthMeasMarkerAlg
class	TruthOverlay
class	TruthSegmentCsvDumperAlg
class	TruthSegmentMaker
class	TruthSegToTruthPartAssocAlg
	The TruthSegToTruthPartAssocAlg associates the TruthSegments with the primary TruthParticle from the IP. More...
class	xAODSegmentCnvAlg
	The xAODSegmentCnvAlg takes MuonR4::Segments and converts them into an xAOD::MuonSegmentContainer. More...
class	xRpcMeasToRpcTrkPrdCnvAlg
	Conversion algorithm to turn xAOD::RpcMeasurements into Trk::RpcPrepData. More...

Typedefs
using	HoughEventData = HoughEventData_impl< ActsPeakFinderForMuon, ActsPeakFinderForMuonCfg >
using	HoughHitType = HoughMaximum::HitType
using	HoughPlane = Acts::HoughTransformUtils::HoughPlane< HoughHitType >
using	ActsPeakFinderForMuon = Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax< HoughHitType >
using	ActsPeakFinderForMuonCfg = Acts::HoughTransformUtils::PeakFinders::IslandsAroundMaxConfig
using	EtaHoughMaxContainer = DataVector< HoughMaximum >
using	SegmentSeedContainer = DataVector< SegmentSeed >
using	SegmentContainer = DataVector< Segment >
using	SpacePointContainer = DataVector< SpacePointBucket >
	Abrivation of the space point container type. More...
using	Covariance_t = CalibratedSpacePoint::Covariance_t
using	HitVec = SpacePointPerLayerSplitter::HitVec
using	MsTrackSeedContainer = std::vector< MsTrackSeed >
using	CalibSpacePointVec = ISpacePointCalibrator::CalibSpacePointVec
using	CalibSpacePointPtr = ISpacePointCalibrator::CalibSpacePointPtr
using	State = CalibratedSpacePoint::State
using	SegLink_t = ElementLink< MuonR4::SegmentContainer >
using	PrdCont_t = xAOD::UncalibratedMeasurementContainer
using	PrdLink_t = ElementLink< PrdCont_t >
using	PrdLinkVec_t = std::vector< PrdLink_t >
using	SegPars_t = xAOD::MeasVector< toInt(ParamDefs::nPars)>
using	TechIdx_t = Muon::MuonStationIndex::TechnologyIndex
using	HitType = SegmentFitResult::HitType
using	SegmentVec = SegmentAmbiSolver::SegmentVec
using	PrimitiveVec = MuonValR4::IPatternVisualizationTool::PrimitiveVec
using	SearchTree_t = MsTrackSeeder::SearchTree_t
using	SegLinkVec_t = std::vector< SegLink_t >
using	MarkerHandle_t = SG::WriteDecorHandle< PrdCont_t, bool >
using	LinkHandle_t = SG::WriteDecorHandle< PrdCont_t, SegLinkVec_t >
using	WriteDecorKey_t = SG::WriteDecorHandleKey< xAOD::UncalibratedMeasurementContainer >
using	SegPars = xAOD::MeasVector< toInt(ParamDefs::nPars)>

Functions
double	houghTanTheta (const Amg::Vector3D &v)
	Returns the hough tanTheta [y] / [z]. More...
double	houghTanPhi (const Amg::Vector3D &v)
	: Returns the hough tanPhi [x] / [z] More...
Amg::Vector3D	multiply (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector3D &v)
	Multiplies a 3D vector with the covariance matrix which can be either 2x2 or 3x3 matrix. More...
Amg::Vector2D	multiply (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector2D &v)
	Multiplies a 2D vector with the covariance matrix which has to be a 2x2 matrix. More...
CalibratedSpacePoint::Covariance_t	inverse (const CalibratedSpacePoint::Covariance_t &mat)
	Inverts the parsed matrix. More...
double	contract (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector3D &a, const Amg::Vector3D &b)
double	contract (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector2D &a, const Amg::Vector2D &b)
double	contract (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector3D &a)
double	contract (const CalibratedSpacePoint::Covariance_t &mat, const Amg::Vector2D &a)
std::string	toString (const CalibratedSpacePoint::Covariance_t &mat)
	Returns the matrix in string. More...
const	AmgSymMatrix (2) &SpacePoint
HitVec	stripSmartPtr (const SpacePointBucket &bucket)
std::ostream &	operator<< (std::ostream &ostr, const MuonR4::MsTrackSeed &seed)
const Segment *	detailedSegment (const xAOD::MuonSegment &seg)
	Helper function to navigate from the xAOD::MuonSegment to the MuonR4::Segment. More...
std::vector< const xAOD::UncalibratedMeasurement * >	collectMeasurements (const Segment &seg, bool skipOutlier=true)
	Helper function to extract the measurements from the segment. More...
const xAOD::MuonSimHit *	getTruthMatchedHit (const xAOD::UncalibratedMeasurement &prdHit)
	Returns the MuonSimHit, if there's any, matched to the uncalibrated muon measurement. More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const xAOD::MuonSegment &segment)
	: Returns all sim hits matched to a xAOD::MuonSegment More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const std::vector< const SpacePoint * > &spacePoints)
	Returns all sim hits that are matched to a collection of space points. More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const std::vector< const CalibratedSpacePoint * > &measurements)
	Returns all sim hits that are matched to a collection of calibrated space points. More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const Segment &seg)
	Returns all sim hits that are matched to the reconstructed segment. More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const SegmentSeed &seed)
	Returns all sim hits that are matched to the segmentSeed. More...
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const SpacePointBucket &bucket)
	Returns all sim hits that are matched to the spacePoint bucket. More...
const xAOD::TruthParticle *	getTruthMatchedParticle (const xAOD::MuonSegment &segment)
	Returns the particle truth-matched to the segment. More...
const xAOD::MuonSegment *	getMatchedTruthSegment (const xAOD::MuonSegment &segment)
	Returns the truth-matched segment. More...
constexpr TechIdx_t	toTechIdx (const xAOD::UncalibMeasType aodType)
constexpr double	sign (const double x)
	Returns the sign of a number. More...
constexpr unsigned int	sumUp (unsigned k)
	Calculates the sum of 1 + 2 +3 +4 +... More...
template<unsigned int n>
constexpr unsigned int	vecIdxFromSymMat (unsigned int i, unsigned k)
	If a n-dimensional Matrix is symmetric, it has n* (n+1) /2 parameters The following function returns the global index when filling the content of the matrix into a vector via for (i = 0; i < n; ++i) { for (k =i; k<n; ++k){ } }. More...
template<int n>
constexpr std::array< unsigned, 2 >	symMatIdxFromVec (unsigned int k)
	Translates back the global index into the two matrix access indices under the assumption that the matrix is symmetric. More...
double	driftCov (const CalibratedSpacePoint &dcHit)
constexpr bool	passRangeCut (const std::array< double, 2 > &cutRange, const double value)
bool	passesThrough (const SpacePointBucket::chamberLocation &loc, double y0, double tanTheta)
double	proximity (const SpacePoint *dc, double y0, double tanTheta)
constexpr double	chamberCoverage (const std::array< double, 2 > &seedEdges, const std::array< double, 2 > &chambEdges)
	Calculates how much of the unkknown coordinate along the tube range is covered by the chamber of interest. More...
MuonR4::SegmentFitResult::HitVec	copy (const MuonR4::SegmentFitResult::HitVec &hits)
MuonR4::SegmentFitResult	copy (const MuonR4::SegmentFitResult &toCopy)
bool	removeBeamSpot (MuonR4::SegmentFitResult::HitVec &hits)
template<class MeasType >
	AmgSymMatrix (2) SpacePointMakerAlg

Variables
constexpr unsigned int	minLayers {4}

Detailed Description

This header ties the generic definitions in this package.

The SegmentActsRefitAlg is designed to test the Acts tracking geometry & the global chi2 fitter at chamber level.

Added a flag in MuonConfig to turn off the R4 sTGC Digitization until fully validated.

: The sTgcMeasViewAlg takes all sTgcStrip, sTgcWire & sTgcPad measurements and pushes them into a common sTgcMeasContainer which is a SG::VIEW_ELEMENTS container

: The RpcMeasViewAlg takes the BI & legacy Rpc measurements and pushes them into a common RpcMeasurmentContainer which is a SG::VIEW_ELEMENTS container

: The MdtMeasViewAlg takes the MdtMeasurments && the MdtTwinMeasurements and combined them into a common MdtDriftCircleContainer

The MuonStripCsvDumperAlg reads the RpcStripContainer and dumps information to csv files The files are used for the algorithm development in acts.

Set of helper functions to fetch the links to the xAOD::MuonSimHits from the uncalibrated measurements.

MsTrackSeed represents the collection of segments that may be compatible with a muon track trajectory hypothesis.

copyright am arsch

the accumulator, and the peak finder.

To construct a seed, the segments are projected onto a cylinder which is roughly intersecting the middle stations of the spectrometer.

The links are decorated by the PrepDataToSimHitAssocAlg which is residing inside the MuonTruthAlgsR4 package. Before using these functions ensure that the algorithms are ran accordingly

Using FastDigi tool at the moment.

Uncalibrated xAOD measurements are collected from previously fitted segments and then passed through the global chi2 fitter. If the fit succeeded, a new xAOD::MuonSegment is created and the parameters as well as the hit summary are saved.

Typedef Documentation

ActsPeakFinderForMuon

using MuonR4::ActsPeakFinderForMuon = typedef Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax<HoughHitType>

Definition at line 24 of file MuonHoughDefs.h.

ActsPeakFinderForMuonCfg

using MuonR4::ActsPeakFinderForMuonCfg = typedef Acts::HoughTransformUtils::PeakFinders::IslandsAroundMaxConfig

Definition at line 26 of file MuonHoughDefs.h.

CalibSpacePointPtr

using MuonR4::CalibSpacePointPtr = typedef ISpacePointCalibrator::CalibSpacePointPtr

Definition at line 27 of file SpacePointCalibrator.cxx.

CalibSpacePointVec

using MuonR4::CalibSpacePointVec = typedef ISpacePointCalibrator::CalibSpacePointVec

Definition at line 26 of file SpacePointCalibrator.cxx.

Covariance_t

using MuonR4::Covariance_t = typedef CalibratedSpacePoint::Covariance_t

Definition at line 8 of file CalibratedSpacePoint.cxx.

EtaHoughMaxContainer

using MuonR4::EtaHoughMaxContainer = typedef DataVector<HoughMaximum>

Definition at line 14 of file MuonPatternContainer.h.

HitType

using MuonR4::HitType = typedef SegmentFitResult::HitType

Definition at line 36 of file MdtSegmentFitter.cxx.

HitVec

typedef SpacePointPerLayerSplitter::HitVec MuonR4::HitVec

Definition at line 11 of file SpacePointPerLayerSplitter.cxx.

HoughEventData

using MuonR4::HoughEventData = typedef HoughEventData_impl<ActsPeakFinderForMuon, ActsPeakFinderForMuonCfg>

Definition at line 71 of file HoughEventData.h.

HoughHitType

using MuonR4::HoughHitType = typedef HoughMaximum::HitType

Definition at line 18 of file MuonHoughDefs.h.

HoughPlane

using MuonR4::HoughPlane = typedef Acts::HoughTransformUtils::HoughPlane<HoughHitType>

Definition at line 20 of file MuonHoughDefs.h.

LinkHandle_t

typedef SG::WriteDecorHandle< PrdCont_t, SegLinkVec_t > MuonR4::LinkHandle_t

Definition at line 21 of file MeasurementMarkerAlg.cxx.

MarkerHandle_t

typedef SG::WriteDecorHandle< PrdCont_t, bool > MuonR4::MarkerHandle_t

Definition at line 20 of file MeasurementMarkerAlg.cxx.

MsTrackSeedContainer

using MuonR4::MsTrackSeedContainer = typedef std::vector<MsTrackSeed>

Definition at line 61 of file MsTrackSeed.h.

PrdCont_t

typedef xAOD::UncalibratedMeasurementContainer MuonR4::PrdCont_t

Definition at line 19 of file xAODSegmentCnvAlg.cxx.

PrdLink_t

typedef ElementLink< PrdCont_t > MuonR4::PrdLink_t

Definition at line 20 of file xAODSegmentCnvAlg.cxx.

PrdLinkVec_t

typedef std::vector< PrdLink_t > MuonR4::PrdLinkVec_t

Definition at line 21 of file xAODSegmentCnvAlg.cxx.

PrimitiveVec

using MuonR4::PrimitiveVec = typedef MuonValR4::IPatternVisualizationTool::PrimitiveVec

Definition at line 59 of file SegmentFittingAlg.cxx.

SearchTree_t

using MuonR4::SearchTree_t = typedef MsTrackSeeder::SearchTree_t

Definition at line 9 of file MsTrackSeeder.cxx.

SegLink_t

typedef ElementLink< xAOD::MuonSegmentContainer > MuonR4::SegLink_t

Definition at line 18 of file xAODSegmentCnvAlg.cxx.

SegLinkVec_t

typedef std::vector< SegLink_t > MuonR4::SegLinkVec_t

Definition at line 15 of file MeasurementMarkerAlg.cxx.

SegmentContainer

using MuonR4::SegmentContainer = typedef DataVector<Segment>

Definition at line 16 of file MuonPatternContainer.h.

SegmentSeedContainer

using MuonR4::SegmentSeedContainer = typedef DataVector<SegmentSeed>

Definition at line 15 of file MuonPatternContainer.h.

SegmentVec

using MuonR4::SegmentVec = typedef SegmentAmbiSolver::SegmentVec

Definition at line 10 of file SegmentAmbiSolver.cxx.

SegPars

using MuonR4::SegPars = typedef xAOD::MeasVector<toInt(ParamDefs::nPars)>

Definition at line 15 of file SegmentFitParDecorAlg.cxx.

SegPars_t

using MuonR4::SegPars_t = typedef xAOD::MeasVector<toInt(ParamDefs::nPars)>

Definition at line 23 of file xAODSegmentCnvAlg.cxx.

SpacePointContainer

using MuonR4::SpacePointContainer = typedef DataVector<SpacePointBucket>

Abrivation of the space point container type.

Definition at line 56 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/MuonSpacePoint/SpacePointContainer.h.

State

using MuonR4::State = typedef CalibratedSpacePoint::State

Definition at line 28 of file SpacePointCalibrator.cxx.

TechIdx_t

typedef Muon::MuonStationIndex::TechnologyIndex MuonR4::TechIdx_t

Definition at line 26 of file xAODSegmentCnvAlg.cxx.

WriteDecorKey_t

typedef SG::WriteDecorHandleKey< xAOD::UncalibratedMeasurementContainer > MuonR4::WriteDecorKey_t

Definition at line 23 of file MeasurementMarkerAlg.cxx.

Function Documentation

AmgSymMatrix() [1/2]

const MuonR4::AmgSymMatrix

(

2

)

&

Definition at line 90 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/SpacePoint.cxx.

                                                         {
        return m_measCovariance;
    }
    void SpacePoint::setInstanceCounts(std::shared_ptr<unsigned int> etaCounts, 
                                       std::shared_ptr<unsigned int> phiCounts) {
        updateInstanceCounts(m_etaInstances, std::move(etaCounts));
        updateInstanceCounts(m_phiInstances, std::move(phiCounts));
    }

AmgSymMatrix() [2/2]

template<class MeasType >

MuonR4::AmgSymMatrix

(

2

)

Definition at line 116 of file SpacePointMakerAlg.cxx.

                                                                             {
    AmgSymMatrix(2) Jac{AmgSymMatrix(2)::Identity()}, uvcov {AmgSymMatrix(2)::Identity()};
        
    if (primaryMeas->numDimensions() == 1) {
        uvcov(0,0) = primaryMeas->template localCovariance<1>()[0];
 
        if constexpr (std::is_same_v<MeasType, xAOD::MdtDriftCircle>) {
            uvcov(1,1) = 0.5* primaryMeas->readoutElement()->activeTubeLength(primaryMeas->measurementHash());
        }
        else if constexpr (std::is_same_v<MeasType, xAOD::RpcMeasurement>) {
            if (primaryMeas->numDimensions() == 1) {
                const xAOD::RpcStrip* strip = static_cast<const xAOD::RpcStrip*>(primaryMeas);
                uvcov(1,1) = strip->measuresPhi() ? 0.5* strip->readoutElement()->stripPhiLength(): 0.5* strip->readoutElement()->stripEtaLength();
            }
        }
        else if constexpr (std::is_same_v<MeasType, xAOD::TgcStrip>){
            if (primaryMeas->measuresPhi()) {
                uvcov(1,1) = 0.5 * primaryMeas->readoutElement()->stripLayout(primaryMeas->gasGap()).stripLength(primaryMeas->channelNumber());
            } else {
                uvcov(1,1) = 0.5 * primaryMeas->readoutElement()->wireGangLayout(primaryMeas->gasGap()).stripLength(primaryMeas->channelNumber());
            }
        }
        else if constexpr (std::is_same_v<MeasType, xAOD::MMCluster>){
            uvcov(1,1) = 0.5 * primaryMeas->readoutElement()->stripLayer(primaryMeas->measurementHash()).design().stripLength(primaryMeas->channelNumber());
        }
        else if constexpr (std::is_same_v<MeasType, xAOD::sTgcMeasurement>){
            switch (primaryMeas->channelType()) {
                case sTgcIdHelper::sTgcChannelTypes::Strip:
                    uvcov(1,1) = 0.5 *  primaryMeas->readoutElement()->stripDesign(primaryMeas->measurementHash()).stripLength(primaryMeas->channelNumber());
                    break;
                case sTgcIdHelper::sTgcChannelTypes::Wire:
                    uvcov(1,1) = 0.5 *  primaryMeas->readoutElement()->wireDesign(primaryMeas->measurementHash()).stripLength(primaryMeas->channelNumber());
                    break;
                case sTgcIdHelper::sTgcChannelTypes::Pad:
                    break;
            }
        }    
        else static_assert(std::false_type::value, "Unsupported measurement type.");
 
        uvcov(1,1) = std::pow(uvcov(1,1), 2);
    }
    else if (primaryMeas->numDimensions() == 2){
        uvcov = xAOD::toEigen(primaryMeas->template localCovariance<2>());
    }
    else THROW_EXCEPTION("Unexpected numDimension for PRD: " << m_idHelperSvc->toString(primaryMeas->identify()));
 
    Jac.col(0)  = nor.block<2,1>(0,0).unit();
    Jac.col(1) = dir.block<2,1>(0,0).unit();
    
    return Jac * uvcov * Jac.inverse();
}
 
AmgSymMatrix(2) SpacePointMakerAlg::computeCov(const xAOD::UncalibratedMeasurement* primaryMeas,
                                               const xAOD::UncalibratedMeasurement* secondaryMeas,
                                               const Amg::Vector3D& nor1,
                                               const Amg::Vector3D& nor2) const {
    AmgSymMatrix(2) Jac{AmgSymMatrix(2)::Identity()}, uvcov {AmgSymMatrix(2)::Identity()};
 
    if (primaryMeas->numDimensions() != 1) THROW_EXCEPTION("Unexpected numDimension");
 
    uvcov(0,0) = primaryMeas->localCovariance<1>()[0];
    uvcov(1,1) = secondaryMeas->localCovariance<1>()[0]; 
 
    Jac.col(0)  = nor1.block<2,1>(0,0).unit();
    Jac.col(1)  = nor2.block<2,1>(0,0).unit();
 
    return Jac * uvcov * Jac.inverse();
}
 
template<class MeasType>
void SpacePointMakerAlg::fillSpacePoint (std::vector<SpacePoint>& pointColl,
                                        const MeasType* primaryMeas,
                                        const Amg::Transform3D& toChamberTrans) const {
    pointColl.emplace_back(primaryMeas);
    SpacePoint& sp {pointColl.back()};
 
    Amg::Vector3D pos {positionInChamber(primaryMeas, toChamberTrans)};
    Amg::Vector3D dir {channelDirInChamber(primaryMeas, toChamberTrans)};
    Amg::Vector3D nor {channelNormalInChamber(primaryMeas, toChamberTrans)};
    AmgSymMatrix(2) cov {computeCov(primaryMeas,dir,nor)};
 
    sp.setDirection(dir);
    sp.setPosition(pos);
    sp.setNormal(nor);
    sp.setCovariance(cov);
}
 
template<class MeasType>
void SpacePointMakerAlg::fillSpacePoint (std::vector<SpacePoint>& pointColl,
                                        const MeasType* primaryMeas,
                                        const MeasType* secondaryMeas,
                                        const Amg::Transform3D& toChamberTrans_eta, 
                                        const Amg::Transform3D& toChamberTrans_phi) const{
    pointColl.emplace_back(primaryMeas, secondaryMeas);
    SpacePoint& sp {pointColl.back()};
 
    Amg::Vector3D dir1 {channelDirInChamber(primaryMeas, toChamberTrans_eta)};
    Amg::Vector3D nor1 {channelNormalInChamber(primaryMeas, toChamberTrans_eta)};
    Amg::Vector3D pos1 {positionInChamber(primaryMeas, toChamberTrans_eta)};
 
    Amg::Vector3D dir2 {channelDirInChamber(secondaryMeas, toChamberTrans_phi)};
    Amg::Vector3D nor2 {channelNormalInChamber(secondaryMeas, toChamberTrans_phi)};
    Amg::Vector3D pos2 {positionInChamber(secondaryMeas, toChamberTrans_phi)};
    
    AmgSymMatrix(2) cov {computeCov(primaryMeas,secondaryMeas,nor1,nor2)};
 
    sp.setDirection(dir1);
    sp.setPosition(pos1 + Amg::intersect<3>(pos2,dir2, pos1, dir1).value_or(0) * dir1);
    sp.setNormal(nor1);
    sp.setCovariance(cov);
}
 
bool SpacePointMakerAlg::SpacePointStatistics::FieldKey::operator<(const FieldKey& other) const{
    if (techIdx != other.techIdx) {
        return static_cast<int>(techIdx) < static_cast<int>(other.techIdx);
    }
    if (stIdx != other.stIdx) {
        return static_cast<int>(stIdx) < static_cast<int>(other.stIdx);
    }
    return eta < other.eta;
}
unsigned int SpacePointMakerAlg::SpacePointStatistics::StatField::allHits() const {
    return measEta + measPhi + measEtaPhi;
}
SpacePointMakerAlg::SpacePointStatistics::SpacePointStatistics(const Muon::IMuonIdHelperSvc* idHelperSvc):
    m_idHelperSvc{idHelperSvc}{}

chamberCoverage()

constexpr double MuonR4::chamberCoverage ( const std::array< double, 2 > &  seedEdges, const std::array< double, 2 > &  chambEdges  )

constexpr

Calculates how much of the unkknown coordinate along the tube range is covered by the chamber of interest.

Parameters

seedEdges	Array encoding the minimal [0] and maximal [1] possible position of the muon along the tube /strip
chambEdges	Array encoding the minmal [1] and maximal [1] position along the strip of a chamber

Partial overlap. The lower side of the seed is covered by the chamber.

Reverse case with the upper side of the seed covered

The chamber is fully embedded in the possible seed range

Definition at line 43 of file EtaHoughTransformAlg.cxx.

                                                                           {
        // The seed is full embedded
        if (chambEdges[0] <= seedEdges[0] && chambEdges[1] >= seedEdges[1]) {
            return 1.;
        }
        else if (chambEdges[0]<= seedEdges[0]) {
            return (chambEdges[1] - seedEdges[0]) / (seedEdges[1] - seedEdges[0]);
        } 
        else if (chambEdges[1] >= seedEdges[1]) {
            return (seedEdges[1] - chambEdges[0]) / (seedEdges[1] - seedEdges[0]);
        }
        else if (seedEdges[0] <= chambEdges[0] && seedEdges[1] >= chambEdges[1]) {
            return (chambEdges[1] -  chambEdges[0]) / (seedEdges[1] - seedEdges[0]);
        }
        return 0.;
    }

collectMeasurements()

std::vector< const xAOD::UncalibratedMeasurement * > MuonR4::collectMeasurements	(	const Segment &	seg,
		bool	skipOutlier = true
	)

Helper function to extract the measurements from the segment.

Parameters

seg	Reference to the segment of interest
skipOutlier	Switch toggling whether outlier measurements or invalid calib state measurements should be ignored

remove all the garbage

remove all the garbage

Definition at line 18 of file TrackingHelpers.cxx.

                                                                                            {
      std::vector<const xAOD::UncalibratedMeasurement*> out{};
      out.reserve(seg.measurements().size()*2);
      for (const auto& meas : seg.measurements()){
        if (skipOutlier && meas->fitState() != CalibratedSpacePoint::State::Valid) {
          continue;
        }
        // Remove the external constraints
        const SpacePoint* sp = meas->spacePoint();
        if (!sp) {
          continue;
        }
        out.emplace_back(sp->primaryMeasurement());
        if (sp->secondaryMeasurement()) {
          out.emplace_back(sp->secondaryMeasurement());
        }
      }
      return out;
    }

contract() [1/4]

double MuonR4::contract	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector2D &	a
	)

Definition at line 24 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                     {
        return contract(mat,a,a);
    }

contract() [2/4]

double MuonR4::contract	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector2D &	a,
		const Amg::Vector2D &	b
	)

Definition at line 27 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                                          {
        return std::visit([&a,&b](const auto& cov) ->double {
                using CovType = std::decay_t<decltype(cov)>;
                if constexpr(std::is_same_v<CovType, AmgSymMatrix(2)>) {
                    return a.dot(cov*b);
                } else {
                    THROW_EXCEPTION("Cannot perform the bilinear product between "<<Amg::toString(a)
                                  <<", "<<Amg::toString(cov)<<", "<<Amg::toString(b));
                }
            return 0.;
        }, mat);
    }

contract() [3/4]

double MuonR4::contract	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector3D &	a
	)

Definition at line 10 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                     {
        return contract(mat,a,a);
    }

contract() [4/4]

double MuonR4::contract	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector3D &	a,
		const Amg::Vector3D &	b
	)

Definition at line 13 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                                          {
        return std::visit([&a,&b](const auto& cov) ->double{
                using CovType = std::decay_t<decltype(cov)>;
                if constexpr(std::is_same_v<CovType, AmgSymMatrix(2)>) {
                    return a.block<2,1>(0,0).dot(cov*b.block<2,1>(0,0));
                } else if constexpr(std::is_same_v<CovType, AmgSymMatrix(3)>){
                    return a.dot(static_cast<const CovType&>(cov)*b);
                }
            return 0.;
        }, mat);
    }

copy() [1/2]

MuonR4::SegmentFitResult MuonR4::copy

(

const MuonR4::SegmentFitResult &

toCopy

)

Definition at line 41 of file SegmentFittingAlg.cxx.

                                                                      {
        MuonR4::SegmentFitResult toRet{};
        toRet.segmentPars = toCopy.segmentPars;
        toRet.calibMeasurements = copy(toCopy.calibMeasurements);
        toRet.chi2 = toCopy.chi2;
        toRet.nDoF = toCopy.nDoF;
        toRet.timeFit = toCopy.timeFit;
        return toRet;
    }

copy() [2/2]

MuonR4::SegmentFitResult::HitVec MuonR4::copy

(

const MuonR4::SegmentFitResult::HitVec &

hits

)

Definition at line 34 of file SegmentFittingAlg.cxx.

                                                                                {
        MuonR4::SegmentFitResult::HitVec copied{};
        copied.reserve(hits.size());
        std::ranges::transform(hits, std::back_inserter(copied), 
                               [](const auto& hit) { return std::make_unique<MuonR4::CalibratedSpacePoint>(*hit);});
        return copied;
    }

detailedSegment()

const Segment * MuonR4::detailedSegment

(

const xAOD::MuonSegment &

seg

)

Helper function to navigate from the xAOD::MuonSegment to the MuonR4::Segment.

The segment should be decorated with 'parentSegment' decoration.

Parameters

seg	Reference to the segment of interest.

Definition at line 7 of file TrackingHelpers.cxx.

                                                               {
        using SegLink_t = ElementLink<SegmentContainer>;
        static const SG::ConstAccessor<SegLink_t> acc{"parentSegment"};
        if (acc.isAvailable(seg)){
           const SegLink_t& link{acc(seg)};
           if (link.isValid()){
                return *link;
           }
        }
        return nullptr;
    }

driftCov()

double MuonR4::driftCov

(

const CalibratedSpacePoint &

dcHit

)

Definition at line 22 of file MdtSegmentSeedGenerator.cxx.

                                                      {
        return std::visit([](const auto& cov) ->double{
            return Amg::error(cov, toInt(AxisDefs::eta));
        }, dcHit.covariance());
    }

getMatchedTruthSegment()

const xAOD::MuonSegment * MuonR4::getMatchedTruthSegment

(

const xAOD::MuonSegment &

segment

)

Returns the truth-matched segment.

Definition at line 111 of file MuonSimHitHelpers.cxx.

                                                                                  {
        using SegLink_t = ElementLink<xAOD::MuonSegmentContainer>;
        static const SG::ConstAccessor<SegLink_t> acc{"truthSegmentLink"};
        if (acc.isAvailable(segment)) {
            const SegLink_t& link{acc(segment)};
            if (link.isValid()){
                return *link;
            }
        }
        return nullptr;
    }

getMatchingSimHits() [1/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const Segment &

seg

)

Returns all sim hits that are matched to the reconstructed segment.

Definition at line 85 of file MuonSimHitHelpers.cxx.

                                                                                       {
        std::vector<const CalibratedSpacePoint*> calibSps{};
        calibSps.reserve(segment.measurements().size());
        std::ranges::transform(segment.measurements(), std::back_inserter(calibSps), [](const auto& meas){return meas.get();});
        return getMatchingSimHits(calibSps);
    }

getMatchingSimHits() [2/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const SegmentSeed &

seed

)

Returns all sim hits that are matched to the segmentSeed.

Definition at line 97 of file MuonSimHitHelpers.cxx.

                                                                                        {
        return getMatchingSimHits(seed.getHitsInMax());
    }

getMatchingSimHits() [3/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const SpacePointBucket &

bucket

)

Returns all sim hits that are matched to the spacePoint bucket.

Definition at line 91 of file MuonSimHitHelpers.cxx.

                                                                                               {
        std::vector<const SpacePoint*> spacePoints{};
        spacePoints.reserve(bucket.size());
        std::ranges::transform(bucket, std::back_inserter(spacePoints), [](const SpacePointBucket::value_type& sp){return sp.get();});
        return getMatchingSimHits(spacePoints);
    }

getMatchingSimHits() [4/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const std::vector< const CalibratedSpacePoint * > &

measurements

)

Returns all sim hits that are matched to a collection of calibrated space points.

Definition at line 69 of file MuonSimHitHelpers.cxx.

                                                                                                                           {
        std::unordered_set<const xAOD::MuonSimHit*> hits{};
        for (const CalibratedSpacePoint* meas : measurements) {
            const SpacePoint* sp = meas->spacePoint();
            if (!sp) continue;
            const xAOD::MuonSimHit* primHit{getTruthMatchedHit(*sp->primaryMeasurement())};
            const xAOD::MuonSimHit* secHit{sp->dimension() == 2 ? getTruthMatchedHit(*sp->secondaryMeasurement()) : nullptr};
            if(primHit){
                hits.insert(primHit);
            }
            if (secHit && secHit != primHit) {
                hits.insert(secHit);
            }
        }
        return hits;
    }

getMatchingSimHits() [5/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const std::vector< const SpacePoint * > &

spacePoints

)

Returns all sim hits that are matched to a collection of space points.

For each spacepoint, the hit truth matching to the primary and secondary prd are retrieved. The secondary hit is only added if it's different from the primary one.

Definition at line 54 of file MuonSimHitHelpers.cxx.

                                                                                                                {
        std::unordered_set<const xAOD::MuonSimHit*> hits{};
        for (const SpacePoint* sp : spacePoints) {
            const xAOD::MuonSimHit* primHit{getTruthMatchedHit(*sp->primaryMeasurement())};
            const xAOD::MuonSimHit* secHit{sp->dimension() == 2 ? getTruthMatchedHit(*sp->secondaryMeasurement()) : nullptr};
            if(primHit){
                hits.insert(primHit);
            }
            if (secHit && secHit != primHit) {
                hits.insert(secHit);
            }
        }
        return hits;
    }

getMatchingSimHits() [6/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getMatchingSimHits

(

const xAOD::MuonSegment &

segment

)

: Returns all sim hits matched to a xAOD::MuonSegment

Definition at line 27 of file MuonSimHitHelpers.cxx.

                                                                                               {
        
        using SimHitLinkVec_t = std::vector<ElementLink<xAOD::MuonSimHitContainer>>;
        using PrdLink_t = ElementLink<xAOD::UncalibratedMeasurementContainer>;
        using PrdLinkVec_t = std::vector<PrdLink_t>;
        
        static const SG::ConstAccessor<SimHitLinkVec_t> acc_simLink{"simHitLinks"};
        static const SG::ConstAccessor<PrdLinkVec_t> acc_prdLink{"prdLinks"};
        std::unordered_set<const xAOD::MuonSimHit*> hits{};
        if (acc_simLink.isAvailable(segment)){
            hits.reserve(acc_simLink(segment).size());
            for (const ElementLink<xAOD::MuonSimHitContainer>& link : acc_simLink(segment)) {
                if (link.isValid()) {
                    hits.insert(*link);
                }
            }
        } else if (acc_prdLink.isAvailable(segment)){
            for (const PrdLink_t& link : acc_prdLink(segment)) {
                const xAOD::MuonSimHit* hit = getTruthMatchedHit(**link);
                if (hit){
                    hits.insert(hit);
                }
            }
        }      
        return hits;
    }

getTruthMatchedHit()

const xAOD::MuonSimHit * MuonR4::getTruthMatchedHit

(

const xAOD::UncalibratedMeasurement &

prdHit

)

Returns the MuonSimHit, if there's any, matched to the uncalibrated muon measurement.

Definition at line 16 of file MuonSimHitHelpers.cxx.

                                                                                        {
        static const SG::ConstAccessor<ElementLink<xAOD::MuonSimHitContainer>> acc("simHitLink");
        if (acc.isAvailable(prdHit)){
            const ElementLink<xAOD::MuonSimHitContainer>& link{acc(prdHit)};
            if (link.isValid()) {
                return (*link);
            }
        }
        return nullptr;
    }

getTruthMatchedParticle()

const xAOD::TruthParticle * MuonR4::getTruthMatchedParticle

(

const xAOD::MuonSegment &

segment

)

Returns the particle truth-matched to the segment.

Definition at line 100 of file MuonSimHitHelpers.cxx.

                                                                                    {
        using TruthLink_t = ElementLink<xAOD::TruthParticleContainer>;
        static const SG::ConstAccessor<TruthLink_t> acc{"truthParticleLink"};
        if (acc.isAvailable(segment)){
            const TruthLink_t& link {acc(segment)};
            if (link.isValid()) {
                return *link;
            }
        }
        return nullptr;
    }

houghTanPhi()

double MuonR4::houghTanPhi

(

const Amg::Vector3D &

v

)

: Returns the hough tanPhi [x] / [z]

Parameters

v	Arbitrary direction vector

Definition at line 18 of file SegmentFitterEventData.cxx.

                                            {            
        constexpr double eps = std::numeric_limits<float>::epsilon();
        return v.x() /  ( std::abs(v.z()) > eps ? v.z() : eps); 
    }

houghTanTheta()

double MuonR4::houghTanTheta

(

const Amg::Vector3D &

v

)

Returns the hough tanTheta [y] / [z].

Parameters

v	Arbitrary direction vector

Definition at line 14 of file SegmentFitterEventData.cxx.

                                              { 
        constexpr double eps = std::numeric_limits<float>::epsilon();
        return v.y() /  ( std::abs(v.z()) > eps ? v.z() : eps); 
    }

inverse()

CalibratedSpacePoint::Covariance_t MuonR4::inverse

(

const CalibratedSpacePoint::Covariance_t &

mat

)

Inverts the parsed matrix.

Definition at line 65 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                          {
        return std::visit([](const auto& cov)-> CalibratedSpacePoint::Covariance_t {
            using CovType = std::decay_t<decltype(cov)>;
            if constexpr(std::is_same_v<CovType, AmgSymMatrix(2)>) {
                return AmgSymMatrix(2){cov.inverse()};
            } else {
                return AmgSymMatrix(3){cov.inverse()};
            }
        }, mat);
    }

multiply() [1/2]

Amg::Vector2D MuonR4::multiply	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector2D &	v
	)

Multiplies a 2D vector with the covariance matrix which has to be a 2x2 matrix.

Otherwise, an exception is thrown

Parameters

mat	Matrix variant
v	Vector which shall be transformed

Definition at line 52 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                            {
        Amg::Vector2D result{Amg::Vector2D::Zero()};
         std::visit([&v, &result](const auto&cov) ->void {
                using CovType = std::decay_t<decltype(cov)>;
                if constexpr(std::is_same_v<CovType, AmgSymMatrix(2)>) {
                    result.block<2,1>(0,0) = cov * v.block<2,1>(0,0);
                } else {
                    THROW_EXCEPTION("Cannot multiply "<<Amg::toString(cov)<<" with "<<Amg::toString(v));
                }
            }, mat);
        return result;
    }

multiply() [2/2]

Amg::Vector3D MuonR4::multiply	(	const CalibratedSpacePoint::Covariance_t &	mat,
		const Amg::Vector3D &	v
	)

Multiplies a 3D vector with the covariance matrix which can be either 2x2 or 3x3 matrix.

In the former case, only the x-y components are transformed

Parameters

mat	Matrix variant
v	Vector which shall be transformed

Definition at line 40 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                                            {
        Amg::Vector3D result{Amg::Vector3D::Zero()};
        std::visit([&v, &result](const auto&cov) ->void {
                using CovType = std::decay_t<decltype(cov)>;
                if constexpr(std::is_same_v<CovType, AmgSymMatrix(2)>) {
                    result.block<2,1>(0,0) = cov * v.block<2,1>(0,0);
                } else{
                    result = cov * v;
                }
        },mat);
        return result;
    }

operator<<()

std::ostream & MuonR4::operator<<	(	std::ostream &	ostr,
		const MuonR4::MsTrackSeed &	seed
	)

Definition at line 10 of file MsTrackSeed.cxx.

                                                                            {
      ostr<<"Seed @"<<Amg::toString(seed.position())<<std::endl;
      for (const xAOD::MuonSegment* seg : seed.segments()) {
        ostr<<"  **** "<<detailedSegment(*seg)->msSector()->identString()<<" "
            <<Amg::toString(seg->position())<<" + "<<Amg::toString(seg->direction())
            <<", chi2: "<<(seg->chiSquared() / seg->numberDoF())
            <<", nPrec: "<<seg->nPrecisionHits()<<", nPhi: "<<seg->nPhiLayers()
            <<", nTrigEta: "<<seg->nTrigEtaLayers()<<std::endl;
      }
      return ostr;
    }

passesThrough()

bool MuonR4::passesThrough ( const SpacePointBucket::chamberLocation &  loc, double  y0, double  tanTheta  )

inline

Definition at line 25 of file EtaHoughTransformAlg.cxx.

                                                                                                      {
        double yCross = (y0 + loc.location().z() * tanTheta);  
        return (loc.minY() < yCross && yCross < loc. maxY()); 
    } 

passRangeCut()

constexpr bool MuonR4::passRangeCut ( const std::array< double, 2 > &  cutRange, const double  value  )

constexpr

Definition at line 27 of file MdtSegmentSeedGenerator.cxx.

                                                                                         {
        return cutRange[0] <= value && value <= cutRange[1];
    }

proximity()

double MuonR4::proximity ( const SpacePoint *  dc, double  y0, double  tanTheta  )

inline

Definition at line 30 of file EtaHoughTransformAlg.cxx.

                                                                              {
        if (dc->type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            return std::min(std::abs(HoughHelpers::Eta::houghParamMdtLeft(tanTheta, dc) - y0), 
                            std::abs(HoughHelpers::Eta::houghParamMdtRight(tanTheta, dc) - y0));
        }
        return std::abs(HoughHelpers::Eta::houghParamStrip(tanTheta, dc) - y0);
    }

removeBeamSpot()

bool MuonR4::removeBeamSpot

(

MuonR4::SegmentFitResult::HitVec &

hits

)

Definition at line 50 of file SegmentFittingAlg.cxx.

                                                           {
        std::size_t before = hits.size();
        hits.erase(std::remove_if(hits.begin(), hits.end(),
                [](const auto& a){
                    return a->type() == xAOD::UncalibMeasType::Other;
                }), hits.end());
        return before != hits.size();
    }

sign()

constexpr double MuonR4::sign ( const double  x )

constexpr

Returns the sign of a number.

Definition at line 11 of file MatrixUtils.h.

                                          {
        return  x > 0. ? 1. : x < 0. ? -1. : 0.;
    }

stripSmartPtr()

HitVec MuonR4::stripSmartPtr ( const SpacePointBucket &  bucket )

inline

Definition at line 12 of file SpacePointPerLayerSplitter.cxx.

                                                                {
        HitVec hits{};
        hits.reserve(bucket.size());
        std::transform(bucket.begin(),bucket.end(),std::back_inserter(hits), 
                      [](const SpacePointBucket::value_type& hit){return hit.get();});
        return hits;
    }

sumUp()

constexpr unsigned int MuonR4::sumUp ( unsigned  k )

constexpr

Calculates the sum of 1 + 2 +3 +4 +...

• k

Definition at line 15 of file MatrixUtils.h.

                                            {
        return k*(k+1)/ 2;
    }

symMatIdxFromVec()

template<int n>

constexpr std::array<unsigned, 2> MuonR4::symMatIdxFromVec ( unsigned int  k )

constexpr

Translates back the global index into the two matrix access indices under the assumption that the matrix is symmetric.

Parameters

k	Global index

Definition at line 41 of file MatrixUtils.h.

                                                                         {
            static_assert(n>=0);
            assert (k < sumUp(n));
            if (k <n) {
                return std::array{0u, k};
            }
            if constexpr(n > 0){
                const auto [i, j] = symMatIdxFromVec<n-1>(k-n); 
                return std::array{i+1u, j+1u};
            }
            return make_array<unsigned, 2>(0);
        }

toString()

std::string MuonR4::toString

(

const CalibratedSpacePoint::Covariance_t &

mat

)

Returns the matrix in string.

Definition at line 75 of file MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/UtilFunctions.cxx.

                                                                    {
         return std::visit([](const auto& cov)-> std::string {
            return Amg::toString(cov);
        }, mat);
    }

toTechIdx()

constexpr TechIdx_t MuonR4::toTechIdx ( const xAOD::UncalibMeasType  aodType )

constexpr

Definition at line 28 of file xAODSegmentCnvAlg.cxx.

                                                                    {
        switch (aodType){
            case xAOD::UncalibMeasType::MdtDriftCircleType:
                return TechIdx_t::MDT;
            case xAOD::UncalibMeasType::RpcStripType:
                return TechIdx_t::RPC;
            case xAOD::UncalibMeasType::TgcStripType:
                return TechIdx_t::TGC;
            case xAOD::UncalibMeasType::MMClusterType:
                return TechIdx_t::MM;
            case xAOD::UncalibMeasType::sTgcStripType:
                return TechIdx_t::STGC;
            default:
                return TechIdx_t::TechnologyUnknown;
        }
    }

vecIdxFromSymMat()

template<unsigned int n>

constexpr unsigned int MuonR4::vecIdxFromSymMat ( unsigned int  i, unsigned  k  )

constexpr

If a n-dimensional Matrix is symmetric, it has n* (n+1) /2 parameters The following function returns the global index when filling the content of the matrix into a vector via for (i = 0; i < n; ++i) { for (k =i; k<n; ++k){ } }.

Parameters

i	Index of the row
j	: Index of the column

Definition at line 28 of file MatrixUtils.h.

                                                                            {
            assert(i<n);
            assert(k<n);
            if (k < i) {
                return vecIdxFromSymMat<n>(k,i);
            }
            constexpr unsigned int nPars = sumUp(n);
            return  nPars - sumUp(n-i) + (k-i);
        }

Variable Documentation

minLayers

constexpr unsigned int MuonR4::minLayers {4}

constexpr

Definition at line 63 of file CombinatorialNSWSeedFinderAlg.cxx.