MuonR4 Namespace Reference

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

Namespaces
namespace	SegmentFit
namespace	FastReco
namespace	HoughHelpers

Classes
class	GlobalPattern
	Data class to represent an eta maximum in hough space. 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	Segment
	Placeholder for what will later be the muon segment EDM representation. More...
class	SegmentSeed
	Representation of a segment seed (a fully processed hough maximum) produced by the hough transform. More...
class	CalibratedSpacePoint
	The calibrated Space point is created during the calibration process. More...
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	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...
struct	HitSummary
	Summary struct to hold the hit counts on the track per MS layer. More...
class	MsTrackSeed
class	IdentifierSorter
	Helper struct to establish a sorting of the muon measurements based on their Identifier. More...
class	SpacePointCalibrator
class	BucketDumperAlg
class	CaloCellsDumperAlg
class	MlHitDumperAlg
class	SegmentDumperAlg
class	TruthMuonVertexDumperAlg
class	RpcClusteringAlg
class	SpacePointCsvDumperAlg
class	TruthSegmentCsvDumperAlg
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	RpcRdoToRpcPrepDataTool
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	xAODSegmentCnvAlg
	The xAODSegmentCnvAlg takes MuonR4::Segments and converts them into a xAOD::MuonSegmentContainer. More...
class	TgcDigitToPrepDataCnvTool
	Conversion tool from Tgc digits -> Tgc xAOD uncalibrated measurements. More...
class	xRpcMeasToTrkPrdCnvAlg
	Conversion algorithm to turn xAOD::RpcMeasurements into Trk::RpcPrepData. More...
class	xTgcMeasToTrkPrdCnvAlg
class	MdtMeasViewAlg
class	RpcMeasViewAlg
class	SegmentViewAlg
class	sTgcMeasViewAlg
class	GeomAlignCondAlg
class	RegionSelectorCondAlg
	Conditions algorithm to create the region selector trigger tables from the R4 readout geoemetry. More...
class	MdtDigitizationTool
class	MM_DigitizationTool
class	MmFastDigiTool
class	MuonDigitizationTool
	Barebone implementation of the I/O infrastructure for all MuonDigitizationTools. More...
class	TruthOverlay
class	RpcFastDigiTool
class	sTgcFastDigiTool
class	sTgcDigitizationTool
class	sTgcDigitMaker
class	TgcFastDigiTool
class	FastReconstructionAlg
	Algorithm executing Phase-2 fast reconstruction. More...
class	SPIdDumperAlg
class	EtaHoughTransformAlg
	Algorithm to handle the eta hough transform. More...
class	NswSegmentFinderAlg
class	PhiHoughTransformAlg
	Algorithm to handle the phi hough transform. More...
class	SegmentActsRefitAlg
class	SegmentFittingAlg
	The SegmentFittingAlg fits straight lines to the Mdt/Rpc/Tgc hits associated with the SegmentSeedPatterns. More...
class	SpacePointMakerAlg
	Data preparation algorithm that transforms the uncalibrated measurements into muon space points. 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	SimHitToTruthPartAssocAlg
	This algorihm associates the SDO / sim hit Identifiers to the truth particle using the HepMCParticle uniqueID to match both. More...
class	TrackToTruthPartAssocAlg
	The TrackToTruthPartAssocAlg matches the reconstructed tracks to truth muons. More...
class	TruthHitSummaryAlg
class	TruthSegmentMaker
class	TruthSegToTruthPartAssocAlg
	The TruthSegToTruthPartAssocAlg associates the TruthSegments with the primary TruthParticle from the IP. More...
class	ISegmentSelectionTool
class	ISpacePointCalibrator
	Interface class to refine the space point calibration with an external seed. More...
class	ITrackSummaryTool
	Interface tool to calculate the hit summary of tracks & track seeds in the MuonSpectrometer. More...
class	MsTrackFindingAlg
class	MsTrackSeeder
	Helper class to group muon sgements that may belong to a muon trajectory. More...
class	SegmentSelectionTool
class	TrackSummaryTool
class	MeasurementMarkerAlg
	Algorithm that marks the uncalibrated measurements making up a segment, where the segment passes an arbitrary selection requirement. More...
class	SegmentFitParDecorAlg
	Algorithm to decorate the local segment parameters onto the xAOD::MuonSegments produced by the legacy muon reconstruction chain. More...
class	SegmentMarkerAlg
class	TruthMeasMarkerAlg

Typedefs
using	GlobalPatternContainer = DataVector<GlobalPattern>
	Abrivation of the GlobalPattern container type.
using	HoughEventData = HoughEventData_impl<ActsPeakFinderForMuon, ActsPeakFinderForMuonCfg>
using	HoughHitType = const SpacePoint*
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.
using	Cov_t = SpacePoint::Cov_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>
	Abrivation of the link to the reco segment container.
using	PrdCont_t = xAOD::UncalibratedMeasurementContainer
	Abrivation to call an uncalibrated measurement container.
using	PrdLink_t = ElementLink<PrdCont_t>
	Abrivation to call the link to an element inside an uncalibrated measurement container.
using	PrdLinkVec_t = std::vector<PrdLink_t>
	Abrivation of a collection of Prd links.
using	SegPars_t = xAOD::MeasVector<Acts::toUnderlying(ParamDefs::nPars)>
	Abrivation of the decorated local segment parameters.
using	sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec
using	LayerIndex = GlobalPatternFinder::LayerIndex
using	PrimitiveVec = MuonValR4::IPatternVisualizationTool::PrimitiveVec
using	SearchTree_t = MsTrackSeeder::SearchTree_t
using	SectorProjector = MsTrackSeeder::SectorProjector
using	Cat_t = HitSummary::HitCategory
using	Stat_t = HitSummary::Status
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<Acts::toUnderlying(ParamDefs::nPars)>

Functions
double	houghTanBeta (const Amg::Vector3D &v)
	Returns the hough tanBeta [y] / [z].
double	houghTanAlpha (const Amg::Vector3D &v)
	: Returns the hough tanAlpha [x] / [z]
bool	isPrecisionHit (const SpacePoint &hit)
	Returns whether the uncalibrated spacepoint is a precision hit (Mdt, micromegas, stgc strips).
bool	isGoodHit (const CalibratedSpacePoint &hit)
	Returns whether the calibrated spacepoint is valid and therefore suitable to be used in the segment fit.
bool	isPrecisionHit (const CalibratedSpacePoint &hit)
	Returns whether the calibrated spacepoint is a precision hit (Mdt, micromegas, stgc strips).
template<Acts::Experimental::CompositeSpacePointContainer cont_t>
std::string	print (const cont_t &container)
	Print a space point container to string.
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.
std::vector< const xAOD::UncalibratedMeasurement * >	collectMeasurements (const xAOD::MuonSegment &segment, bool skipOutlier=true)
	Helper function to extract the measurements from the segment.
std::string	printID (const xAOD::MuonSegment &seg)
	Print the chamber ID of a segment, e.g.
std::size_t	nMeasurements (const xAOD::MuonSegment &segment)
	Returns the number of associated Uncalibrated measurements.
const xAOD::UncalibratedMeasurement *	getMeasurement (const xAOD::MuonSegment &segment, const std::size_t n)
	Returns the n-th uncalibrated measurement.
bool	isOutlierMeasurement (const xAOD::MuonSegment &segment, const std::size_t n)
	Returns whether the n-the uncalibrated measurement is an outlier.
Acts::GeometryIdentifier	volumeId (const Acts::Surface &surface)
	Returns the identifier of the volume in which the surface is embedded.
const xAOD::MuonSimHit *	getTruthMatchedHit (const xAOD::MuonMeasurement &prdHit)
	Returns the MuonSimHit, if there's any, matched to the uncalibrated muon measurement.
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const xAOD::MuonSegment &segment)
	: Returns all sim hits matched to a xAOD::MuonSegment
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.
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.
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const Segment &seg)
	Returns all sim hits that are matched to the reconstructed segment.
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const SegmentSeed &seed)
	Returns all sim hits that are matched to the segmentSeed.
std::unordered_set< const xAOD::MuonSimHit * >	getMatchingSimHits (const SpacePointBucket &bucket)
	Returns all sim hits that are matched to the spacePoint bucket.
const xAOD::TruthParticle *	getTruthMatchedParticle (const xAOD::MuonSegment &segment)
	Returns the particle truth-matched to the segment.
const xAOD::MuonSegment *	getMatchedTruthSegment (const xAOD::MuonSegment &segment)
	Returns the truth-matched segment.
std::vector< const xAOD::MuonSegment * >	getTruthSegments (const xAOD::TruthParticle &truthMuon)
	Returns the segments associated to the truth muon.
const xAOD::MuonSegment *	getMatchedTruthSegment (const xAOD::MuonSimHit &hit)
	Returns the segment matched to the sim hit.
const xAOD::TruthParticle *	getTruthMatchedParticle (const xAOD::MuonSimHit &hit)
	Returns the truth particle matched to the sim hit.
bool	passesThrough (const SpacePointBucket::chamberLocation &loc, double y0, double tanBeta)
double	proximity (const SpacePoint *dc, double y0, double tanBeta)
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.

Variables
constexpr unsigned	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.

Set of helper functions for uncalibrated / calibrated space points meant for local and global pattern recognition.

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 = Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax<HoughHitType>

Definition at line 30 of file MuonHoughDefs.h.

ActsPeakFinderForMuonCfg

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

Definition at line 32 of file MuonHoughDefs.h.

CalibSpacePointPtr

using MuonR4::CalibSpacePointPtr = ISpacePointCalibrator::CalibSpacePointPtr

Definition at line 39 of file SpacePointCalibrator.cxx.

CalibSpacePointVec

using MuonR4::CalibSpacePointVec = ISpacePointCalibrator::CalibSpacePointVec

Definition at line 38 of file SpacePointCalibrator.cxx.

Cat_t

using MuonR4::Cat_t = HitSummary::HitCategory

Definition at line 20 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

Cov_t

using MuonR4::Cov_t = SpacePoint::Cov_t

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

EtaHoughMaxContainer

using MuonR4::EtaHoughMaxContainer = DataVector<HoughMaximum>

Definition at line 14 of file MuonPatternContainer.h.

GlobalPatternContainer

using MuonR4::GlobalPatternContainer = DataVector<GlobalPattern>

Abrivation of the GlobalPattern container type.

Definition at line 105 of file GlobalPattern.h.

HitVec

using MuonR4::HitVec = SpacePointPerLayerSplitter::HitVec

Definition at line 12 of file SpacePointPerLayerSplitter.cxx.

HoughEventData

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

Definition at line 71 of file HoughEventData.h.

HoughHitType

using MuonR4::HoughHitType = const SpacePoint*

Definition at line 24 of file MuonHoughDefs.h.

HoughPlane

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

Definition at line 26 of file MuonHoughDefs.h.

LayerIndex

using MuonR4::LayerIndex = GlobalPatternFinder::LayerIndex

Definition at line 9 of file MuonFastReconstructionAlg.cxx.

LinkHandle_t

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

Definition at line 21 of file MeasurementMarkerAlg.cxx.

MarkerHandle_t

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

Definition at line 20 of file MeasurementMarkerAlg.cxx.

MsTrackSeedContainer

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

Definition at line 63 of file MsTrackSeed.h.

PrdCont_t

typedef xAOD::MuonMeasurementContainer MuonR4::PrdCont_t = xAOD::UncalibratedMeasurementContainer

Abrivation to call an uncalibrated measurement container.

Definition at line 26 of file xAODSegmentCnvAlg.cxx.

PrdLink_t

typedef ElementLink< PrdCont_t > MuonR4::PrdLink_t = ElementLink<PrdCont_t>

Abrivation to call the link to an element inside an uncalibrated measurement container.

Definition at line 29 of file xAODSegmentCnvAlg.cxx.

PrdLinkVec_t

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

Abrivation of a collection of Prd links.

Definition at line 31 of file xAODSegmentCnvAlg.cxx.

PrimitiveVec

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

Definition at line 22 of file SegmentFittingAlg.cxx.

SearchTree_t

using MuonR4::SearchTree_t = MsTrackSeeder::SearchTree_t

Definition at line 51 of file MsTrackSeeder.cxx.

SectorProjector

using MuonR4::SectorProjector = MsTrackSeeder::SectorProjector

Definition at line 52 of file MsTrackSeeder.cxx.

SegLink_t

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

Abrivation of the link to the reco segment container.

Definition at line 24 of file xAODSegmentCnvAlg.cxx.

SegLinkVec_t

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

Definition at line 15 of file MeasurementMarkerAlg.cxx.

SegmentContainer

using MuonR4::SegmentContainer = DataVector<Segment>

Definition at line 16 of file MuonPatternContainer.h.

SegmentSeedContainer

using MuonR4::SegmentSeedContainer = DataVector<SegmentSeed>

Definition at line 15 of file MuonPatternContainer.h.

SegPars

using MuonR4::SegPars = xAOD::MeasVector<Acts::toUnderlying(ParamDefs::nPars)>

Definition at line 17 of file SegmentFitParDecorAlg.cxx.

SegPars_t

using MuonR4::SegPars_t = xAOD::MeasVector<Acts::toUnderlying(ParamDefs::nPars)>

Abrivation of the decorated local segment parameters.

Definition at line 33 of file xAODSegmentCnvAlg.cxx.

SpacePointContainer

using MuonR4::SpacePointContainer = DataVector<SpacePointBucket>

Abrivation of the space point container type.

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

Stat_t

using MuonR4::Stat_t = HitSummary::Status

Definition at line 21 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

State

using MuonR4::State = CalibratedSpacePoint::State

Definition at line 40 of file SpacePointCalibrator.cxx.

sTgcDigitVec

using MuonR4::sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec

Definition at line 25 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

WriteDecorKey_t

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

Definition at line 23 of file MeasurementMarkerAlg.cxx.

Function Documentation

chamberCoverage()

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 xAOD::MuonSegment &	segment,
		bool	skipOutlier = true )

Helper function to extract the measurements from the segment.

Parameters

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

Definition at line 56 of file TrackingHelpers.cxx.

                                                                                            {
        std::vector<const xAOD::UncalibratedMeasurement*> out{};
        const PrdLinkVec_t& links{acc_prdLinks(segment)};
        out.reserve(links.size());
        for (std::size_t l = 0 ; l < links.size(); ++l) {
            const PrdLink_t& link{links[l]};
            if (!skipOutlier || !isOutlierMeasurement(segment, l)) {
                out.push_back(*link);
            }
        }
        return out;
    }

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

getMatchedTruthSegment() [1/2]

const xAOD::MuonSegment * MuonR4::getMatchedTruthSegment

(

const xAOD::MuonSegment &

segment

)

Returns the truth-matched segment.

Definition at line 125 of file MuonSimHitHelpers.cxx.

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

getMatchedTruthSegment() [2/2]

const xAOD::MuonSegment * MuonR4::getMatchedTruthSegment

(

const xAOD::MuonSimHit &

hit

)

Returns the segment matched to the sim hit.

Definition at line 136 of file MuonSimHitHelpers.cxx.

                                                                             {
        static const SG::ConstAccessor<SegLink_t> acc{"truthSegmentLink"};
        if (acc.isAvailable(hit)) {
            const SegLink_t& link{acc(hit)};
            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 99 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 111 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 105 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 83 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 68 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 38 of file MuonSimHitHelpers.cxx.

                                                                                               {
        
        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 SimHitLink_t& link : acc_simLink(segment)) {
                if (link.isValid()) {
                    hits.insert(*link);
                }
            }
        } else if (acc_prdLink.isAvailable(segment)){
            for (const PrdLink_t& link : acc_prdLink(segment)) {
                if(!link.isValid()){
                    continue;
                }
                const auto* prdHit = dynamic_cast<const xAOD::MuonMeasurement*>(*link);
                if (!prdHit) {
                    continue;
                }
                const xAOD::MuonSimHit* hit = getTruthMatchedHit(*prdHit);
                if (hit){
                    hits.insert(hit);
                }
            }
        }      
        return hits;
    }

getMeasurement()

const xAOD::UncalibratedMeasurement * MuonR4::getMeasurement	(	const xAOD::MuonSegment &	segment,
		const std::size_t	n )

Returns the n-th uncalibrated measurement.

Parameters

segment	Reference to the segment of interest
n	Index of the measurement to retrieve

Definition at line 39 of file TrackingHelpers.cxx.

                                                                           {
      if (!acc_prdLinks.isAvailable(segment)) {
          return nullptr;
      }
      assert(n < nMeasurements(segment));
      const PrdLink_t& link{acc_prdLinks(segment)[n]};
      return link.isValid() ? *link : nullptr;
    } 

getTruthMatchedHit()

const xAOD::MuonSimHit * MuonR4::getTruthMatchedHit

(

const xAOD::MuonMeasurement &

prdHit

)

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

Definition at line 27 of file MuonSimHitHelpers.cxx.

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

getTruthMatchedParticle() [1/2]

const xAOD::TruthParticle * MuonR4::getTruthMatchedParticle

(

const xAOD::MuonSegment &

segment

)

Returns the particle truth-matched to the segment.

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

getTruthMatchedParticle() [2/2]

const xAOD::TruthParticle * MuonR4::getTruthMatchedParticle

(

const xAOD::MuonSimHit &

hit

)

Returns the truth particle matched to the sim hit.

Definition at line 146 of file MuonSimHitHelpers.cxx.

                                                                                {
        const xAOD::MuonSegment* truthSeg = getMatchedTruthSegment(hit);
        return truthSeg ? getTruthMatchedParticle(*truthSeg) : nullptr;
    }

getTruthSegments()

std::vector< const xAOD::MuonSegment * > MuonR4::getTruthSegments

(

const xAOD::TruthParticle &

truthMuon

)

Returns the segments associated to the truth muon.

Definition at line 151 of file MuonSimHitHelpers.cxx.

                                                                                           {
        static const SG::ConstAccessor<SegLinkVec_t> acc{"truthSegmentLinks"};
        std::vector<const xAOD::MuonSegment*> segments{};
 
        if (!acc.isAvailable(truthMuon)) {
            return segments;
        }
        for (const SegLink_t& link : acc(truthMuon)) {
            segments.emplace_back(*link);
        }
        return segments;
    }

houghTanAlpha()

double MuonR4::houghTanAlpha

(

const Amg::Vector3D &

v

)

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

Parameters

v	Arbitrary direction vector

Definition at line 30 of file SegmentFitterEventData.cxx.

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

houghTanBeta()

double MuonR4::houghTanBeta

(

const Amg::Vector3D &

v

)

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

Parameters

v	Arbitrary direction vector

Definition at line 26 of file SegmentFitterEventData.cxx.

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

isGoodHit()

bool MuonR4::isGoodHit

(

const CalibratedSpacePoint &

hit

)

Returns whether the calibrated spacepoint is valid and therefore suitable to be used in the segment fit.

Parameters

hit	Reference to the calibrated space point of interest

Definition at line 16 of file SpacePointHelpers.cxx.

                                                {
    using enum CalibratedSpacePoint::State;
    return hit.fitState() == Valid;
}

isOutlierMeasurement()

bool MuonR4::isOutlierMeasurement	(	const xAOD::MuonSegment &	segment,
		const std::size_t	n )

Returns whether the n-the uncalibrated measurement is an outlier.

Parameters

segment	Reference to the segment of interest
n	Index of the measurement to retrieve

Definition at line 48 of file TrackingHelpers.cxx.

                                                 {
        if(!acc_prdState.isAvailable(segment)) {
            return false;
        }
        assert (n < acc_prdState(segment).size());
        return acc_prdState(segment)[n] != Acts::toUnderlying(CalibratedSpacePoint::State::Valid);
    }

isPrecisionHit() [1/2]

bool MuonR4::isPrecisionHit

(

const CalibratedSpacePoint &

hit

)

Returns whether the calibrated spacepoint is a precision hit (Mdt, micromegas, stgc strips).

Parameters

hit	Reference to the calibrated space point of interest

Definition at line 20 of file SpacePointHelpers.cxx.

                                                     {
    using enum xAOD::UncalibMeasType;
    if (hit.type() == xAOD::UncalibMeasType::Other){
        return false;
    }
    return isGoodHit(hit) && isPrecisionHit(*hit.spacePoint());
}

isPrecisionHit() [2/2]

bool MuonR4::isPrecisionHit

(

const SpacePoint &

hit

)

Returns whether the uncalibrated spacepoint is a precision hit (Mdt, micromegas, stgc strips).

Parameters

hit	Reference to the uncalibrated space point

Definition at line 9 of file SpacePointHelpers.cxx.

                                           {
    using enum xAOD::UncalibMeasType;
    return hit.type() == MdtDriftCircleType || hit.type() == MMClusterType ||
            (hit.type() == sTgcStripType && 
            static_cast<const xAOD::sTgcMeasurement*>(hit.primaryMeasurement())->channelType() ==
            sTgcIdHelper::sTgcChannelTypes::Strip);
}

nMeasurements()

std::size_t MuonR4::nMeasurements

(

const xAOD::MuonSegment &

segment

)

Returns the number of associated Uncalibrated measurements.

Parameters

segment

Reference to the segment of interest

Definition at line 36 of file TrackingHelpers.cxx.

                                                            {
      return acc_prdLinks.isAvailable(segment) ? acc_prdLinks(segment).size() : 0;
    }

operator<<()

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

Definition at line 16 of file MsTrackSeed.cxx.

                                                                            {
      ostr<<"MS Track seed @"<<Amg::toString(seed.position())<<", sector: "<<seed.sector() << ", location: "<< Acts::toUnderlying(seed.location())<< std::endl;
      using namespace Muon::MuonStationIndex;
      for (const xAOD::MuonSegment* seg : seed.segments()) {
        ostr<<"  **** "<< printID(*seg)
            <<", theta: "<<(seg->direction().theta() /Gaudi::Units::degree)
            <<", phi: "<<(seg->direction().phi() /Gaudi::Units::degree)
            <<", R: "<<Acts::fastHypot(seg->x(), seg->y())
            <<", Z: "<<seg->z()<<" "<<(seg->position().theta() / Gaudi::Units::degree)
            // <<", "<<SegmentFit::toString(SegmentFit::localSegmentPars(*seg))
            <<", chi2: "<<(seg->chiSquared() / std::max(seg->numberDoF(), 1.f))
            <<", nPrec: "<<seg->nPrecisionHits()
            <<", nPhi: "<<seg->nPhiLayers()
            <<", nTrigEta: "<<seg->nTrigEtaLayers()<<std::endl;
      }
      return ostr;
    }

passesThrough()

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

inline

Definition at line 25 of file EtaHoughTransformAlg.cxx.

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

print()

template<Acts::Experimental::CompositeSpacePointContainer cont_t>

std::string MuonR4::print

(

const cont_t &

container

)

Print a space point container to string.

Parameters

container

Reference to the space point container to print

printID()

std::string MuonR4::printID

(

const xAOD::MuonSegment &

seg

)

Print the chamber ID of a segment, e.g.

BMS1A12, meaning that the segment is in the first BMS eta station on the A-side in sector 12

Parameters

seg	Reference to the segment from which the id should be printed

Definition at line 17 of file TrackingHelpers.cxx.

                                                 {
        using namespace Muon::MuonStationIndex;
        return std::format("{:}{:}{:}{:}", chName(seg.chamberIndex()),
                                                  std::abs(seg.etaIndex()),
                                                  seg.etaIndex() > 0 ? 'A' : 'C',
                                                  seg.sector());
    }

proximity()

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

inline

Definition at line 30 of file EtaHoughTransformAlg.cxx.

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

volumeId()

Acts::GeometryIdentifier MuonR4::volumeId

(

const Acts::Surface &

surface

)

Returns the identifier of the volume in which the surface is embedded.

Parameters

surface

Reference to the surface of interest

Definition at line 69 of file TrackingHelpers.cxx.

                                                                 {
        return surface.geometryId().withSensitive(0).withBoundary(0);
     }

Variable Documentation

minLayers

unsigned MuonR4::minLayers {4}

constexpr

Definition at line 79 of file NswSegmentFinderAlg.cxx.

{4};