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	CalibSegmentChi2Minimizer

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	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

class	MM_DigitizationTool

class	MmFastDigiTool

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

class	PrepDataToSimHitAssocAlg
	The PrepDataToSimHitAssocAlg matches the uncalibrated measurements to the MuonSimHits or to the MuonSDO objects. More...

class	RpcClusteringAlg

class	RpcFastDigiTool

class	RpcMeasViewAlg

class	RpcRdoToRpcPrepDataTool

class	Segment
	Placeholder for what will later be the muon segment EDM representation. More...

class	SegmentAmbiSolver

class	SegmentCnvAlg
	The SegmentCnvAlg 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	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	SegmentViewAlg

class	SimHitCsvDumperAlg

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 groups the space points by their layer Identifier. More...

class	sTgcFastDigiTool

class	sTgcMeasViewAlg

class	TgcFastDigiTool

class	TruthMeasMarkerAlg

class	TruthOverlay

class	TruthSegmentCsvDumperAlg

class	TruthSegmentMaker

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 >

using	Covariance_t = CalibratedSpacePoint::Covariance_t

using	HitVec = SpacePointPerLayerSorter::HitVec

using	CalibSpacePointVec = ISpacePointCalibrator::CalibSpacePointVec

using	CalibSpacePointPtr = ISpacePointCalibrator::CalibSpacePointPtr

using	State = CalibratedSpacePoint::State

using	HitType = CalibSegmentChi2Minimizer::HitType

using	SegmentVec = SegmentAmbiSolver::SegmentVec

using	PrimitiveVec = MuonValR4::IPatternVisualizationTool::PrimitiveVec

using	PrdCont_t = xAOD::UncalibratedMeasurementContainer

using	SegLink_t = ElementLink< xAOD::MuonSegmentContainer >

using	SegLinkVec_t = std::vector< SegLink_t >

using	PrdLink_t = ElementLink< PrdCont_t >

using	PrdLinkVec_t = std::vector< PrdLink_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)>

using	PrdLinkVec = std::vector< PrdLink_t >

using	TechIdx_t = Muon::MuonStationIndex::TechnologyIndex

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...

void	sortByLayer (std::vector< const SpacePoint * > &spacePoints)
	Sorts the space points in a vector by z. More...

const	AmgSymMatrix (2) &SpacePoint

HitVec	stripSmartPtr (const SpacePointBucket &bucket)

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 * >	getTruthMatchedHits (const xAOD::MuonSegment &segment)
	: Returns all truth hits matched to a xAOD::MuonSegment More...

std::unordered_set< const xAOD::MuonSimHit * >	getTruthMatchedHits (const std::vector< const SpacePoint * > &spacePoints)
	Returns all truth hits that are matched to a collection of space points. More...

std::unordered_set< const xAOD::MuonSimHit * >	getTruthMatchedHits (const std::vector< const CalibratedSpacePoint * > &measurements)
	Returns all truth hits that are matched to a collection of calibrated space points. More...

std::unordered_set< const xAOD::MuonSimHit * >	getTruthMatchedHits (const Segment &seg)
	Returns all truth hits that are matched to the reconstructed segment. More...

std::unordered_set< const xAOD::MuonSimHit * >	getTruthMatchedHits (const SegmentSeed &seed)
	Returns all truth hits that are matched to the segmentSeed. More...

std::unordered_set< const xAOD::MuonSimHit * >	getTruthMatchedHits (const SpacePointBucket &bucket)
	Returns all truth hits that are matched to the spacePoint bucket. More...

double	driftCov (const CalibratedSpacePoint &dcHit)

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

MuonR4::SegmentFitResult::HitVec	copy (const MuonR4::SegmentFitResult::HitVec &hits)

MuonR4::SegmentFitResult	copy (const MuonR4::SegmentFitResult &toCopy)

bool	removeBeamSpot (MuonR4::SegmentFitResult::HitVec &hits)

Variables
constexpr double	inv_c = 1./ Gaudi::Units::c_light

Detailed Description

This header ties the generic definitions in this package.

: 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.

The CsvMuonSimHitDumper reads a Simulation Hit container for muons and dumps information to csv files.

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

copyright am arsch

the accumulator, and the peak finder.

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

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 23 of file SpacePointCalibrator.cxx.

◆ CalibSpacePointVec

using MuonR4::CalibSpacePointVec = typedef ISpacePointCalibrator::CalibSpacePointVec

Definition at line 22 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

typedef SegmentFitResult::HitType MuonR4::HitType

Definition at line 15 of file CalibSegmentChi2Minimizer.cxx.

◆ HitVec

typedef SpacePointPerLayerSorter::HitVec MuonR4::HitVec

Definition at line 9 of file SpacePointPerLayerSorter.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.

◆ PrdCont_t

typedef xAOD::UncalibratedMeasurementContainer MuonR4::PrdCont_t

Definition at line 13 of file MeasurementMarkerAlg.cxx.

◆ PrdLink_t

typedef ElementLink< PrdCont_t > MuonR4::PrdLink_t

Definition at line 17 of file MeasurementMarkerAlg.cxx.

◆ PrdLinkVec

using MuonR4::PrdLinkVec = typedef std::vector<PrdLink_t>

Definition at line 18 of file SegmentFitParDecorAlg.cxx.

◆ PrdLinkVec_t

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

Definition at line 18 of file MeasurementMarkerAlg.cxx.

◆ PrimitiveVec

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

Definition at line 60 of file SegmentFittingAlg.cxx.

◆ SegLink_t

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

Definition at line 14 of file MeasurementMarkerAlg.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.

◆ SpacePointContainer

using MuonR4::SpacePointContainer = typedef DataVector<SpacePointBucket>

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

◆ State

using MuonR4::State = typedef CalibratedSpacePoint::State

Definition at line 24 of file SpacePointCalibrator.cxx.

◆ TechIdx_t

using MuonR4::TechIdx_t = typedef Muon::MuonStationIndex::TechnologyIndex

Definition at line 19 of file SegmentFitParDecorAlg.cxx.

◆ WriteDecorKey_t

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

Definition at line 23 of file MeasurementMarkerAlg.cxx.

Function Documentation

◆ AmgSymMatrix()

const MuonR4::AmgSymMatrix ( 2 ) &

Definition at line 150 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));
     }

◆ 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 42 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 35 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;
     }

◆ 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());
     }

◆ 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 13 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;
     }

◆ getTruthMatchedHits() [1/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const Segment & seg )

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

Definition at line 71 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 getTruthMatchedHits(calibSps);
     }

◆ getTruthMatchedHits() [2/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const SegmentSeed & seed )

Returns all truth hits that are matched to the segmentSeed.

Definition at line 83 of file MuonSimHitHelpers.cxx.

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

◆ getTruthMatchedHits() [3/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const SpacePointBucket & bucket )

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

Definition at line 77 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 getTruthMatchedHits(spacePoints);
     }

◆ getTruthMatchedHits() [4/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const std::vector< const CalibratedSpacePoint * > & measurements )

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

Definition at line 55 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;
     }

◆ getTruthMatchedHits() [5/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const std::vector< const SpacePoint * > & spacePoints )

Returns all truth 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 40 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;
     }

◆ getTruthMatchedHits() [6/6]

std::unordered_set< const xAOD::MuonSimHit * > MuonR4::getTruthMatchedHits ( const xAOD::MuonSegment & segment )

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

Definition at line 24 of file MuonSimHitHelpers.cxx.

                                                                                                 {
         using SimHitLinkVec = std::vector<ElementLink<xAOD::MuonSimHitContainer>>; 
         static const SG::ConstAccessor<SimHitLinkVec> acc{"simHitLinks"};
         std::unordered_set<const xAOD::MuonSimHit*> hits{};
         if (!acc.isAvailable(segment)){
             return hits;
         }
         hits.reserve(acc(segment).size());
         for (const ElementLink<xAOD::MuonSimHitContainer>& link : acc(segment)) {
             if (link.isValid()) {
                 hits.insert(*link);
             }
         }
         return hits;
     }

◆ 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;
     }

◆ 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];
     }

◆ removeBeamSpot()

bool MuonR4::removeBeamSpot ( MuonR4::SegmentFitResult::HitVec & hits )

Definition at line 51 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();
     }

◆ sortByLayer()

void MuonR4::sortByLayer ( std::vector< const SpacePoint * > & spacePoints )

Sorts the space points in a vector by z.

Parameters

spacePoints List of hits to be sorted

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

                                                                 {
         std::ranges::sort(spacePoints, 
               [](const SpacePoint*& a, const SpacePoint*& b){   
                     const Amg::Vector3D& hitA{a->positionInChamber()};
                     const Amg::Vector3D& hitB{b->positionInChamber()};
                     constexpr double layerTol = 1.*Gaudi::Units::mm;
                     if (std::abs(hitA.z() - hitB.z()) > layerTol) {
                         return hitA.z() < hitB.z();
                     }
                     return hitA.y() < hitB.y();
               });
     }

◆ stripSmartPtr()

HitVec MuonR4::stripSmartPtr ( const SpacePointBucket & bucket )

inline

Definition at line 10 of file SpacePointPerLayerSorter.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;
     }

◆ 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);
     }

Variable Documentation

◆ inv_c

constexpr double MuonR4::inv_c = 1./ Gaudi::Units::c_light

constexpr

Definition at line 32 of file SegmentFittingAlg.cxx.

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ ActsPeakFinderForMuon

◆ ActsPeakFinderForMuonCfg

◆ CalibSpacePointPtr

◆ CalibSpacePointVec

◆ Covariance_t

◆ EtaHoughMaxContainer

◆ HitType

◆ HitVec

◆ HoughEventData

◆ HoughHitType

◆ HoughPlane

◆ LinkHandle_t

◆ MarkerHandle_t

◆ PrdCont_t

◆ PrdLink_t

◆ PrdLinkVec

◆ PrdLinkVec_t

◆ PrimitiveVec

◆ SegLink_t

◆ SegLinkVec_t

◆ SegmentContainer

◆ SegmentSeedContainer

◆ SegmentVec

◆ SegPars

◆ SpacePointContainer

◆ State

◆ TechIdx_t

◆ WriteDecorKey_t

Function Documentation

◆ AmgSymMatrix()

◆ contract() [1/4]

◆ contract() [2/4]

◆ contract() [3/4]

◆ contract() [4/4]

◆ copy() [1/2]

◆ copy() [2/2]

◆ driftCov()

◆ getTruthMatchedHit()

◆ getTruthMatchedHits() [1/6]

◆ getTruthMatchedHits() [2/6]

◆ getTruthMatchedHits() [3/6]

◆ getTruthMatchedHits() [4/6]

◆ getTruthMatchedHits() [5/6]

◆ getTruthMatchedHits() [6/6]

◆ houghTanPhi()

◆ houghTanTheta()

◆ inverse()

◆ multiply() [1/2]

◆ multiply() [2/2]

◆ passRangeCut()

◆ removeBeamSpot()

◆ sortByLayer()

◆ stripSmartPtr()

◆ toString()

Variable Documentation

◆ inv_c