The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.). More...

Namespaces
	Cache

	detail

	details

	FitterHelperFunctions

	HitCategory

	ParticleHypothesis

Classes
class	ActsToTrkConverterTool

class	ActsToTrkConvertorAlg

class	AdaptiveMultiPriVtxFinderTool

class	AlignStoreProviderAlg

class	AmbiguityResolutionAlg

class	AnalogueClusteringToolImpl

struct	ATLASSourceLinkSurfaceAccessor

struct	ATLASUncalibSourceLinkSurfaceAccessor

class	CaloBasedRoICreatorTool

class	ClusterizationAlg

class	ConstTrackContainerHandlesHelper

class	CoreStripSpacePointFormationTool

struct	DataLinkHolder

class	DataPreparationAlg

class	DetectorAlignCondAlg

class	DetectorAlignStore

class	DetectorVolumeSvc

class	DummyRDOList

class	EstimatedTrackParamsAnalysisAlg

class	FullScanRoICreatorTool

class	GaussianSumFitter

class	GeometryContextAlg

struct	has_rdoList

struct	has_rdoList< Object, std::void_t< rdoListFunc_t< Object > > >

class	HgtdClusterAnalysisAlg

class	HgtdClusterValidationPlots

class	HitCounterArray

class	HitCountsPerTrack
	Container for hit counts per track Contains hit counts per associated truth particle and the total hit counts As last element in the container. More...

class	HitSummaryData
	Helper class to gather hit summary information for e.g. More...

class	IActsToTrkConverterTool

class	IDetectorElement

class	IDetectorVolumeBuilderTool

class	IDetectorVolumeSvc
	Interface of the service providing the Acts::Detector which implements the navigation delegate paradigm and eventually replace the legacy tracking geometry. More...

class	IFitterTool

class	IOnTrackCalibratorTool

class	IPixelClusteringTool

class	IPixelSpacePointFormationTool

class	IProtoTrackCreatorTool

class	IRoICreatorTool

class	ISeedingTool

class	IStripClusteringTool

class	IStripSpacePointFormationTool

class	IterativePriVtxFinderTool

class	ITkAnalogueClusteringTool

class	ITrackParamsEstimationTool

class	KalmanFitter

class	MeasurementCalibratorBase

class	MeasurementToTruthAssociationAlg
	Algorithm template to associate measurements of a certain type to a xAOD truth particles using a sim data collection where the sim data collection contains associates RDOs to truth particles and there energy/charge disposition. More...

class	MultiTrajectory
	Read only version of MTJ The implementation is separate as the details are significantly different and in addition only const methods are ever needed. More...

class	MuonDetectorBuilderTool

class	MutableMultiTrajectory
	Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends. More...

struct	MutableTrackContainer

class	MutableTrackContainerHandlesHelper

class	MutableTrackSummaryContainer

class	NoDeletePtr

class	OnTrackCalibrator

class	OrthogonalSeedingTool

class	PhysValTool

class	PixelCacheClusterizationAlg

class	PixelCacheSpacePointFormationAlg

class	PixelClusterAnalysisAlg

class	PixelClusterCacheDataPreparationAlg

class	PixelClusterDataPreparationAlg

class	PixelClusteringTool

class	PixelClusterizationAlg

class	PixelClusterToTruthAssociationAlg

class	PixelClusterValidationPlots

class	PixelSpacePointFormationAlg

class	PixelSpacePointFormationAlgBase

class	PixelSpacePointFormationTool

class	PixelSpacePointValidationPlots

struct	PRDSourceLink

struct	PRDSourceLinkCalibrator

struct	PRDSourceLinkSurfaceAccessor

struct	ProtoTrack

class	ProtoTrackCreationAndFitAlg

class	ProtoTrackReportingAlg
	Very lightweight algorithm to print out the results of the EF track finding. More...

class	RandomProtoTrackCreator

class	ReFitterAlg

class	RegionsOfInterestCreatorAlg

class	SeedAnalysisAlg

class	SeedingAlg

class	SeedingAlgorithmAnalysisAlg

class	SeedingTool

class	SimpleCylinderDetBuilderTool

class	SiSpacePointsSeedMaker

class	SpacePointAnalysisAlg

class	SpacePointCacheDataPreparationAlg

class	SpacePointDataPreparationAlg

class	SpacePointReader

class	StripCacheClusterizationAlg

class	StripCacheSpacePointFormationAlg

class	StripClusterAnalysisAlg

class	StripClusterCacheDataPreparationAlg

class	StripClusterDataPreparationAlg

class	StripClusteringTool

class	StripClusterizationAlg

class	StripClusterToTruthAssociationAlg

class	StripClusterValidationPlots

class	StripInformationHelper

struct	StripSP

class	StripSpacePointFormationAlg

class	StripSpacePointFormationAlgBase

class	StripSpacePointFormationTool

class	StripSpacePointValidationPlots

class	SumOfValues
	Helper class to gather statistics and compute the biased variance. More...

class	SurfaceBoundSet

class	SurfaceCache
	: Helper class to connect the aligned transformations of each active sensor(layer) with the Acts::Surfaces. More...

class	TestRoICreatorTool

class	TrackAnalysisAlg

class	TrackContainer

class	TrackContainerReader

class	TrackFindingAlg

class	TrackFindingValidationAlg

class	TrackMergerAlg

class	TrackParamsEstimationTool

class	TrackParticleAnalysisAlg

class	TrackStatePrinter

class	TrackSummaryContainer

class	TrackToTrackParticleCnvAlg

class	TrackToTruthAssociationAlg

class	TransformCache

class	TransformCacheDetEle

class	TrkMeasurementCalibrator

class	TrkToActsConvertorAlg
	Algorithm convert Trk::Track to ACTS multistate objects. More...

class	TruthGuidedProtoTrackCreator

class	TruthParticleHitCountAlg

Typedefs
using	IndexType = std::uint32_t

using	ParticleVector = boost::container::small_vector< const xAOD::TruthParticle *, NTruthParticlesPerMeasurement >

using	MeasurementToTruthParticleAssociation = std::vector< ParticleVector >

using	StoredSurface = std::variant< const Acts::Surface *, std::shared_ptr< const Acts::Surface > >

typedef Acts::Seed< xAOD::SpacePoint >	Seed

typedef DataVector< Acts::Seed< xAOD::SpacePoint > >	SeedContainer

using	MutableTrackBackend = ActsTrk::MutableTrackSummaryContainer

using	TrackBackend = ActsTrk::TrackSummaryContainer

using	MutableTrackStateBackend = ActsTrk::MutableMultiTrajectory

using	TrackStateBackend = ActsTrk::MultiTrajectory

using	TrackContainerBase = Acts::TrackContainer< ActsTrk::TrackBackend, ActsTrk::TrackStateBackend, ActsTrk::DataLinkHolder >

typedef DataVector< Acts::BoundTrackParameters >	BoundTrackParametersContainer

using	ConstParameters = Acts::TrackStateTraits< 3 >::Parameters

using	ConstCovariance = Acts::TrackStateTraits< 3 >::Covariance

using	Parameters = Acts::TrackStateTraits< 3, false >::Parameters

using	Covariance = Acts::TrackStateTraits< 3, false >::Covariance

using	TrackToTruthParticleAssociation = std::vector< HitCountsPerTrack >

using	TruthParticleHitCounts = std::unordered_map< const xAOD::TruthParticle *, HitCounterArray >

using	ATLASSourceLink = const Trk::MeasurementBase *

using	ATLASUncalibSourceLink = const xAOD::UncalibratedMeasurement *

using	TicketCounterArr = DetectorAlignStore::TrackingAlignStore::TicketCounterArr

using	ReturnedTicketArr = DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr

using	ReturnedHintArr = DetectorAlignStore::TrackingAlignStore::ReturnedHintArr

template<class BoundType >
using	SurfaceBoundSetPtr = std::shared_ptr< SurfaceBoundSet< BoundType > >
	Aberivation to create a new SurfaceBoundSetPtr. More...

using	SurfaceCacheSet = std::set< std::unique_ptr< SurfaceCache >, std::less<> >

using	StripRDORawData = SCT_RDORawData

template<typename Object >
using	rdoListFunc_t = decltype(std::declval< Object >().rdoList())

Enumerations
enum	NeighbourIndices { ThisOne, Opposite, PhiMinus, PhiPlus, EtaMinus, EtaPlus, nNeighbours }
	Total number of neightbours and indices. More...

enum	DetectorType : unsigned short { DetectorType::Pixel, DetectorType::Sct, DetectorType::Trt, DetectorType::Hgtd, DetectorType::Mdt, DetectorType::Rpc, DetectorType::Tgc, DetectorType::Csc, DetectorType::Mm, DetectorType::sTgc, DetectorType::UnDefined }
	Simple enum to Identify the Type of the ACTS sub detector. More...

Functions
void	clusterAddCell (PixelClusteringTool::Cluster &cl, const PixelClusteringTool::Cell &cell)

template<typename IFACE , typename AUX >
std::unique_ptr< IFACE >	makeInterfaceContainer (const AUX *aux)
	helper to construct interface container for already filled Aux container TODO maybe should be moved to xAOD area More...

void	encodeSurface (xAOD::TrackSurfaceAuxContainer backend, size_t index, const Acts::Surface surface, const Acts::GeometryContext &geoContext)
	Prepares persistifiable representation of surface into xAOD::TrackSurface object. More...

void	encodeSurface (xAOD::TrackSurface backend, const Acts::Surface surface, const Acts::GeometryContext &geoContext)
	As above, but works on xAOD::TrackSurface object. More...

std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::TrackSurface *backend, const Acts::GeometryContext &geoContext)
	Creates transient Acts Surface objects given a surface backend implementation should be exact mirror of encodeSurface. More...

std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::TrackSurfaceAuxContainer *backend, size_t i, const Acts::GeometryContext &geoContext)
	As above, but takes data from Aux container at an index i. More...

std::string	prefixFromTrackContainerName (const std::string &tracks)
	Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks, the XYZ is returned. More...

void	encodeSurface (xAOD::SurfaceType &surfaceType, std::vector< float > &translation, std::vector< float > &rotation, std::vector< float > &boundValues, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)

std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::SurfaceType surfaceType, const std::vector< float > &translation, const std::vector< float > &rotation, const std::vector< float > &boundValues, const Acts::GeometryContext &)

template<typename T , typename IFACE , typename AUX >
void	recordxAOD (const SG::WriteHandleKey< T > &key, IFACE &iface, AUX &aux, const EventContext &context)

const xAOD::UncalibratedMeasurement &	getUncalibratedMeasurement (const ATLASUncalibSourceLink &source_link)

ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index, [[maybe_unused]] const EventContext &ctx)

ATLASUncalibSourceLink	makeATLASUncalibSourceLink ([[maybe_unused]] const xAOD::UncalibratedMeasurementContainer container, const xAOD::UncalibratedMeasurement measurement, [[maybe_unused]] const EventContext &ctx)

ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index)

ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurement *measurement)

float	localXFromSourceLink (const ATLASUncalibSourceLink &source_link)

float	localYFromSourceLink (const ATLASUncalibSourceLink &source_link)

std::string	to_string (const DetectorType &type)

bool	operator< (const std::unique_ptr< SurfaceCache > &a, const std::unique_ptr< SurfaceCache > &b)
	Comparison operators. More...

bool	operator< (const IdentifierHash &a, const std::unique_ptr< SurfaceCache > &b)

bool	operator< (const std::unique_ptr< SurfaceCache > &a, const IdentifierHash &b)

Acts::Logging::Level	actsLevelVector (MSG::Level lvl)

MSG::Level	athLevelVector (Acts::Logging::Level lvl)

double	computeDtDs (const Acts::ParticleHypothesis &hypothesis, double qop)
	Helper function to compute dt/ds Helper function to compute the derivative of the time as function of the path length. More...

Acts::FreeToPathMatrix	computeFreeToPathDerivatives (const Acts::Vector3 &direction, double qop, const Acts::Vector3 &bfield, const Acts::ParticleHypothesis &particle_hypothesis)
	Compute the path length derivatives for the free/bound to curvilinear paramter transform. More...

std::optional< Acts::BoundMatrix >	convertActsBoundCovToCurvilinearParam (const Acts::GeometryContext &tgContext, const Acts::BoundTrackParameters &param, const Acts::Vector3 &magnFieldVect, const Acts::ParticleHypothesis &particle_hypothesis)
	Convert the covariance of the given Acts track parameters into curvilinear parameterisation. More...

std::array< unsigned int, 4 >	expectedLayerPattern (const EventContext &ctx, const IActsExtrapolationTool &extrapolator, Acts::BoundTrackParameters perigee_parameters, const Acts::CylinderSurface &extrapolation_volume)
	Extrapolate from the perigee outwards and gather information which detector layers should have hits. More...

void	gatherTrackSummaryData (const ActsTrk::TrackContainer &tracksContainer, const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const std::array< const InDetDD::SiDetectorElementCollection *, to_underlying(xAOD::UncalibMeasType::nTypes)> &siDetEleColl, const std::array< unsigned short, to_underlying(xAOD::UncalibMeasType::nTypes)> &measurement_to_summary_type, SumOfValues &chi2_stat_out, HitSummaryData &hit_info_out, std::vector< ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > &param_state_idx_out, std::array< std::array< uint8_t, to_underlying(HitCategory::N)>, to_underlying(xAOD::UncalibMeasType::nTypes)> &special_hit_counts_out)
	Helper to gather track summary information from the track states of the specified track. More...

template<typename T_EnumClass >
constexpr std::underlying_type< T_EnumClass >::type	to_underlying (T_EnumClass an_enum)
	Helper to convert class enum into an integer. More...

template<class T >
auto	getRDOList (const T &a)

template<class T_TruthEventCollection >
auto	makeDepositToTruthParticleMap (const T_TruthEventCollection *truth_particle_links)

template<class T_TruthEventCollection >
const char *	getInTruthPropertyName ()

template<class T_SimDataCollection , class T_SimDataIterator >
auto	getSimDataDeposits (const T_SimDataCollection &sim_data_collection, T_SimDataIterator sim_data_iter_for_identifier)

template<class T_Deposit >
float	getDepositedEnergy (const T_Deposit &)

MsgStream &	operator<< (MsgStream &out, const ActsUtils::Stat &stat)

Variables
constexpr double	ONE_TWELFTH = 1./12.

constexpr unsigned int	NTruthParticlesPerMeasurement = 5

constexpr unsigned int	NHitCounter = static_cast< std::underlying_type<xAOD::UncalibMeasType>::type >(xAOD::UncalibMeasType::nTypes) - 1u

constexpr unsigned int	NTruthParticlesPerTrack = 5

constexpr bool	TrackFindingValidationDebugHists = false

constexpr bool	TrackToTruthParticleAssociationDebugHists = false

constexpr bool	TruthParticleHitCountDebugHists = false

Detailed Description

The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.).

: The NoDeletePtr is a shared_ptr with disabled deleter.

Includes the GeoPrimitives.

Load ATLAS Eigen library with custom geometry functions.

Put first the GeoPrimitives.

small non-persistent data class to wrap the output of the EF-tracking development pattern finding placeholder

The DetectorAlignCondAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.).

The transformations are cached in the DetectorAlignmentStore which is later propagated to the ActsGeometryContext.

The ActsFromGeoAlignStore is an adaptor to go from the GeoModel world caching the rigid transformations of the detector elements to the Acts world where transformations

Then load the Acts TypeDef definitions for Eigen

In AthSimulation, the Acts core library is not available yet

ATLAS extension of the Acts::DetectorElementBase. The extension provides extra methods to identify the element within the ATLAS identifier scheme and also the enum indicating to which tracking subsystem the DetectorElement belongs to. Finally, the detector element provides the interface to optionally precache the aligned transformations in the external AlignmentStore of the geometry context.

Typedef Documentation

◆ ATLASSourceLink

using ActsTrk::ATLASSourceLink = typedef const Trk::MeasurementBase *

Definition at line 24 of file ATLASSourceLink.h.

◆ ATLASUncalibSourceLink

using ActsTrk::ATLASUncalibSourceLink = typedef const xAOD::UncalibratedMeasurement *

Definition at line 25 of file ATLASSourceLink.h.

◆ BoundTrackParametersContainer

typedef DataVector< Acts::BoundTrackParameters > ActsTrk::BoundTrackParametersContainer

Definition at line 12 of file Tracking/Acts/ActsEvent/ActsEvent/TrackParameters.h.

◆ ConstCovariance

using ActsTrk::ConstCovariance = typedef Acts::TrackStateTraits<3>::Covariance

Definition at line 50 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

◆ ConstParameters

using ActsTrk::ConstParameters = typedef Acts::TrackStateTraits<3>::Parameters

Definition at line 49 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

◆ Covariance

using ActsTrk::Covariance = typedef Acts::TrackStateTraits<3, false>::Covariance

Definition at line 52 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

◆ IndexType

typedef std::uint32_t ActsTrk::IndexType

Definition at line 13 of file Decoration.h.

◆ MeasurementToTruthParticleAssociation

using ActsTrk::MeasurementToTruthParticleAssociation = typedef std::vector<ParticleVector>

Definition at line 13 of file MeasurementToTruthParticleAssociation.h.

◆ MutableTrackBackend

using ActsTrk::MutableTrackBackend = typedef ActsTrk::MutableTrackSummaryContainer

Definition at line 12 of file TrackContainer.h.

◆ MutableTrackStateBackend

using ActsTrk::MutableTrackStateBackend = typedef ActsTrk::MutableMultiTrajectory

Definition at line 14 of file TrackContainer.h.

◆ Parameters

using ActsTrk::Parameters = typedef Acts::TrackStateTraits<3, false>::Parameters

Definition at line 51 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

◆ ParticleVector

using ActsTrk::ParticleVector = typedef boost::container::small_vector<const xAOD::TruthParticle *, NTruthParticlesPerMeasurement>

Definition at line 12 of file MeasurementToTruthParticleAssociation.h.

◆ rdoListFunc_t

template<typename Object >

using ActsTrk::rdoListFunc_t = typedef decltype(std::declval<Object>().rdoList())

Definition at line 94 of file MeasurementToTruthAssociationAlg.h.

◆ ReturnedHintArr

using ActsTrk::ReturnedHintArr = typedef DetectorAlignStore::TrackingAlignStore::ReturnedHintArr

Definition at line 16 of file DetectorAlignStore.cxx.

◆ ReturnedTicketArr

using ActsTrk::ReturnedTicketArr = typedef DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr

Definition at line 15 of file DetectorAlignStore.cxx.

◆ Seed

typedef Acts::Seed< xAOD::SpacePoint > ActsTrk::Seed

Definition at line 13 of file Seed.h.

◆ SeedContainer

typedef DataVector< Acts::Seed< xAOD::SpacePoint > > ActsTrk::SeedContainer

Definition at line 14 of file Seed.h.

◆ StoredSurface

using ActsTrk::StoredSurface = typedef std::variant<const Acts::Surface*, std::shared_ptr<const Acts::Surface> >

Definition at line 68 of file MultiTrajectory.h.

◆ StripRDORawData

using ActsTrk::StripRDORawData = typedef SCT_RDORawData

Definition at line 21 of file IStripClusteringTool.h.

◆ SurfaceBoundSetPtr

template<class BoundType >

using ActsTrk::SurfaceBoundSetPtr = typedef std::shared_ptr<SurfaceBoundSet<BoundType> >

Aberivation to create a new SurfaceBoundSetPtr.

Definition at line 50 of file SurfaceBoundSet.h.

◆ SurfaceCacheSet

using ActsTrk::SurfaceCacheSet = typedef std::set<std::unique_ptr<SurfaceCache>, std::less<> >

Definition at line 63 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

◆ TicketCounterArr

using ActsTrk::TicketCounterArr = typedef DetectorAlignStore::TrackingAlignStore::TicketCounterArr

Definition at line 14 of file DetectorAlignStore.cxx.

◆ TrackBackend

using ActsTrk::TrackBackend = typedef ActsTrk::TrackSummaryContainer

Definition at line 13 of file TrackContainer.h.

◆ TrackContainerBase

using ActsTrk::TrackContainerBase = typedef Acts::TrackContainer<ActsTrk::TrackBackend, ActsTrk::TrackStateBackend, ActsTrk::DataLinkHolder>

Definition at line 26 of file TrackContainer.h.

◆ TrackStateBackend

using ActsTrk::TrackStateBackend = typedef ActsTrk::MultiTrajectory

Definition at line 15 of file TrackContainer.h.

◆ TrackToTruthParticleAssociation

using ActsTrk::TrackToTruthParticleAssociation = typedef std::vector<HitCountsPerTrack>

Definition at line 69 of file TrackToTruthParticleAssociation.h.

◆ TruthParticleHitCounts

using ActsTrk::TruthParticleHitCounts = typedef std::unordered_map<const xAOD::TruthParticle *,HitCounterArray>

Definition at line 19 of file TruthParticleHitCounts.h.

Enumeration Type Documentation

◆ DetectorType

enum ActsTrk::DetectorType : unsigned short

strong

Simple enum to Identify the Type of the ACTS sub detector.

Enumerator
Pixel	Inner detector legacy.
Sct
Trt	Maybe the Sct / Pixel for Itk become seperate entries?
Hgtd
Mdt	MuonSpectrometer.
Rpc	Monitored Drift Tubes.
Tgc	Resitive Plate Chambers.
Csc	Thin gap champers.
Mm	Maybe not needed in the migration.
sTgc	Micromegas (NSW)
UnDefined	Small Thing Gap chambers (NSW)

Definition at line 17 of file GeometryDefs.h.

                            : unsigned short {
         Pixel,
         Sct,
         Trt,
         Hgtd,
         Mdt,  
         Rpc,  
         Tgc,  
         Csc,  
         Mm,   
         sTgc,  
         UnDefined
     };

◆ NeighbourIndices

enum ActsTrk::NeighbourIndices

Total number of neightbours and indices.

Enumerator
ThisOne
Opposite
PhiMinus
PhiPlus
EtaMinus
EtaPlus
nNeighbours

Definition at line 13 of file StripInformationHelper.h.

13 {ThisOne, Opposite, PhiMinus, PhiPlus, EtaMinus, EtaPlus, nNeighbours};

Function Documentation

◆ actsLevelVector()

Acts::Logging::Level ActsTrk::actsLevelVector ( MSG::Level lvl )

Definition at line 9 of file LoggerUtils.cxx.

                                                  {
     // MSG::NIL and MSG::ALWAYS are not available in Acts. Need to protect against these
     // For MSG::NIL we can return a Acts::Logging::Level::FATAL;
     // For MSG::ALWAYS we can return a Acts::Logging::Level::VERBOSE
  
     // Gaudi definitions are +1 w.r.t. Acts definitions  
     static const std::array<Acts::Logging::Level, 8> actsLevelVector{
       Acts::Logging::Level::FATAL, // MSG::NIL
       Acts::Logging::Level::VERBOSE,
       Acts::Logging::Level::DEBUG,
       Acts::Logging::Level::INFO,
       Acts::Logging::Level::WARNING,
       Acts::Logging::Level::ERROR,
       Acts::Logging::Level::FATAL,
       Acts::Logging::Level::VERBOSE // MSG::ALWAYS
     };
  
     return actsLevelVector[static_cast<int>(lvl)];
   }

◆ athLevelVector()

MSG::Level ActsTrk::athLevelVector ( Acts::Logging::Level lvl )

Definition at line 29 of file LoggerUtils.cxx.

                                                 {
     // All Acts log levels are available in Gaudi, no need for protections
     static const std::array<MSG::Level, 6> athLevelVector{
       MSG::VERBOSE,
       MSG::DEBUG,
       MSG::INFO,
       MSG::WARNING,
       MSG::ERROR,
       MSG::FATAL
     };   
     return athLevelVector[static_cast<int>(lvl)];
   }

◆ clusterAddCell()

void ActsTrk::clusterAddCell	(	PixelClusteringTool::Cluster &	cl,
		const PixelClusteringTool::Cell &	cell
	)

Definition at line 21 of file PixelClusteringTool.cxx.

 {
   cl.ids.push_back(cell.ID);
   cl.tots.push_back(cell.TOT);
   if (cell.LVL1 < cl.lvl1min)
     cl.lvl1min = cell.LVL1;
 }

◆ computeDtDs()

double ActsTrk::computeDtDs	(	const Acts::ParticleHypothesis &	hypothesis,
		double	qop
	)

inline

Helper function to compute dt/ds Helper function to compute the derivative of the time as function of the path length.

Definition at line 15 of file CurvilinearCovarianceHelper.h.

                                                                                    {
       return std::hypot(1.,hypothesis.mass() / hypothesis.extractMomentum(qop));
    }

◆ computeFreeToPathDerivatives()

Acts::FreeToPathMatrix ActsTrk::computeFreeToPathDerivatives	(	const Acts::Vector3 &	direction,
		double	qop,
		const Acts::Vector3 &	bfield,
		const Acts::ParticleHypothesis &	particle_hypothesis
	)

inline

Compute the path length derivatives for the free/bound to curvilinear paramter transform.

Parameters

direction	the direction of trajectory at the location in question
qop	q/p of the particle at the location in question in Acts units
bfield	the magnetic field at the location in question in Acts units
particle_hypothesis	the particle hypothesis e.g. Acts::ParticleHypothesis::pion()

Returns: path length derivatives ( dr(...)/ds, dt/ds, dr(...)/ds2, d qop/ds [== 0] )

Definition at line 26 of file CurvilinearCovarianceHelper.h.

    {
       Acts::FreeToPathMatrix path_length_deriv;
       static_assert(path_length_deriv.cols() == 8);  // ensure that all elements are initialized
       path_length_deriv.segment<3>(Acts::eFreePos0) = direction;
       path_length_deriv(0,Acts::eFreeTime) =  computeDtDs(particle_hypothesis,qop);
       path_length_deriv.segment<3>(Acts::eFreeDir0) = (qop  * direction.cross(bfield)).transpose();
       path_length_deriv(0,Acts::eFreeQOverP) = 0.;
       return path_length_deriv;
    }

◆ convertActsBoundCovToCurvilinearParam()

std::optional<Acts::BoundMatrix> ActsTrk::convertActsBoundCovToCurvilinearParam	(	const Acts::GeometryContext &	tgContext,
		const Acts::BoundTrackParameters &	param,
		const Acts::Vector3 &	magnFieldVect,
		const Acts::ParticleHypothesis &	particle_hypothesis
	)

inline

Convert the covariance of the given Acts track parameters into curvilinear parameterisation.

Parameters

tgContext	the current geometry context
param	the Acts track parameters
magnFieldVect	the vector of the magnetic field at the position of the track parameters in Acts units
particle_hypothesis	the particle hypothesis e.g. Acts::ParticleHypothesis::pion() Usage: `using namespace Acts::UnitLiterals; MagField::AtlasFieldCache fieldCache; ... Amg::Vector3D magnFieldVect; fieldCache.getField(param.position(tgContext).data(), magnFieldVect.data()); magnFieldVect *= 1000_T; auto cov = convertActsBoundCovToCurvilinearParam(tgContext, param, magnFieldVect); if (cov.has_value()) { ... }`

Definition at line 60 of file CurvilinearCovarianceHelper.h.

    {
       if (param.covariance().has_value()) {
          Acts::FreeVector freeParams = Acts::transformBoundToFreeParameters(
              param.referenceSurface(), tgContext, param.parameters());
          Acts::Vector3 position = freeParams.segment<3>(Acts::eFreePos0);
          Acts::Vector3 direction = freeParams.segment<3>(Acts::eFreeDir0);
          Acts::BoundMatrix b2c;
          Acts::detail::boundToCurvilinearTransportJacobian(direction, // magnFieldVect.normalized(),
                                                            param.referenceSurface().boundToFreeJacobian(tgContext, position, direction),
                                                            Acts::FreeMatrix::Identity(),
                                                            computeFreeToPathDerivatives(direction,
                                                                                         param.parameters()[Acts::eBoundQOverP],
                                                                                         magnFieldVect,
                                                                                         particle_hypothesis),
                                                            b2c);
  
          return b2c * param.covariance().value() * b2c.transpose();
       }
       else {
          return {};
       }
    }

◆ decodeSurface() [1/3]

std::shared_ptr<const Acts::Surface> ActsTrk::decodeSurface	(	const xAOD::SurfaceType	surfaceType,
		const std::vector< float > &	translation,
		const std::vector< float > &	rotation,
		const std::vector< float > &	boundValues,
		const Acts::GeometryContext &
	)

Definition at line 74 of file SurfaceEncoding.cxx.

                                 {
  
   // Translation and rotation
  
   // create the transformation matrix
   auto transform = Acts::Transform3(
       Acts::Translation3(translation[0], translation[1], translation[2]));
   transform *=
       Acts::AngleAxis3(rotation[0], Acts::Vector3(0., 0., 1.));  // rotZ
   transform *=
       Acts::AngleAxis3(rotation[1], Acts::Vector3(0., 1., 0.));  // rotY
   transform *=
       Acts::AngleAxis3(rotation[2], Acts::Vector3(1., 0., 0.));  // rotX
  
   // cone
   if (surfaceType == xAOD::Cone) {
     auto surface = Acts::Surface::makeShared<Acts::ConeSurface>(
         transform, boundValues[0], boundValues[1], boundValues[2],
         boundValues[3]);
     return surface;
   }
   // Cylinder
   else if (surfaceType == xAOD::Cylinder) {
     // phi/2 must be slightly < Pi to avoid crashing
     float fixedPhi =
         boundValues[2] > M_PI - 0.001 ? M_PI - 0.001 : boundValues[2];
     auto surface = Acts::Surface::makeShared<Acts::CylinderSurface>(
         transform, boundValues[0], boundValues[1], fixedPhi, boundValues[3],
         boundValues[4]);
     return surface;
   }
   // Disc
   else if (surfaceType == xAOD::Disc) {
     auto surface = Acts::Surface::makeShared<Acts::DiscSurface>(
         transform, boundValues[0], boundValues[1], boundValues[2]);
     return surface;
   }
   // Perigee
   else if (surfaceType == xAOD::Perigee) {
     auto surface = Acts::Surface::makeShared<Acts::PerigeeSurface>(transform);
     return surface;
   }
   // Plane
   else if (surfaceType == xAOD::Plane) {
     Acts::Vector2 min(boundValues[0], boundValues[1]),
         max(boundValues[2], boundValues[3]);
     auto rBounds = std::make_shared<const Acts::RectangleBounds>(min, max);
     auto surface =
         Acts::Surface::makeShared<Acts::PlaneSurface>(transform, rBounds);
     return surface;
   }
   // Straw
   else if (surfaceType == xAOD::Straw) {
     auto surface = Acts::Surface::makeShared<Acts::StrawSurface>(
         transform, boundValues[0], boundValues[1]);
     return surface;
   } else {
     throw std::out_of_range(
         "encodeSurface this type " +
         std::to_string(static_cast<int>(surfaceType)) +
         " of Acts Surface can not be saved in xAOD::TrackSurface");
     return nullptr;
   }
   return nullptr;
 }

◆ decodeSurface() [2/3]

std::shared_ptr< const Acts::Surface > ActsTrk::decodeSurface	(	const xAOD::TrackSurface *	backend,
		const Acts::GeometryContext &	geoContext
	)

Creates transient Acts Surface objects given a surface backend implementation should be exact mirror of encodeSurface.

Definition at line 143 of file SurfaceEncoding.cxx.

                                                                {
   return decodeSurface(s->surfaceType(), s->translation(), s->rotation(),
                        s->boundValues(), geo);
 }

◆ decodeSurface() [3/3]

std::shared_ptr< const Acts::Surface > ActsTrk::decodeSurface	(	const xAOD::TrackSurfaceAuxContainer *	backend,
		size_t	i,
		const Acts::GeometryContext &	geoContext
	)

As above, but takes data from Aux container at an index i.

Definition at line 149 of file SurfaceEncoding.cxx.

                                     {
   return decodeSurface(s->surfaceType[i], s->translation[i], s->rotation[i],
                        s->boundValues[i], geo);
 }

◆ encodeSurface() [1/3]

void ActsTrk::encodeSurface	(	xAOD::SurfaceType &	surfaceType,
		std::vector< float > &	translation,
		std::vector< float > &	rotation,
		std::vector< float > &	boundValues,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

Definition at line 7 of file SurfaceEncoding.cxx.

                                                           {
   // return if surf is a nullptr
   if (surface == nullptr) {
     return;
   }
  
   // surface type specifics
   if (surface->type() == Acts::Surface::Cone) {
     surfaceType = xAOD::SurfaceType::Cone;
   } else if (surface->type() == Acts::Surface::Cylinder) {
     surfaceType = xAOD::SurfaceType::Cylinder;
   } else if (surface->type() == Acts::Surface::Disc) {
     surfaceType = xAOD::SurfaceType::Disc;
   } else if (surface->type() == Acts::Surface::Perigee) {
     surfaceType = xAOD::SurfaceType::Perigee;
   } else if (surface->type() == Acts::Surface::Plane) {
     surfaceType = xAOD::SurfaceType::Plane;
   } else if (surface->type() == Acts::Surface::Straw) {
     surfaceType = xAOD::SurfaceType::Straw;
   } else {
     throw std::out_of_range(
         "encodeSurface this type " +
         std::to_string(static_cast<int>(surface->type())) +
         " of Acts Surface can not be saved in xAOD::TrackSurface");
     return;
   }
  
   Acts::RotationMatrix3 lRotation =
       surface->transform(geoContext).rotation();
   Acts::Vector3 eulerAngles = lRotation.eulerAngles(2, 1, 0);
   Acts::Vector3 lTranslation = surface->center(geoContext);
  
   for (int i = 0; i < 3; i++) {
     rotation.push_back(eulerAngles[i]);
     translation.push_back(lTranslation[i]);
   }
  
   // Transforming double->float
   const std::vector<double> values = surface->bounds().values();
   for (unsigned int i = 0; i < size(values); i++)
     boundValues.push_back(values[i]);
 }

◆ encodeSurface() [2/3]

void ActsTrk::encodeSurface	(	xAOD::TrackSurface *	backend,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

As above, but works on xAOD::TrackSurface object.

Definition at line 62 of file SurfaceEncoding.cxx.

                                                    {
   xAOD::SurfaceType surfaceType;
   std::vector<float> translation, rotation, bounds;
   encodeSurface(surfaceType, translation, rotation, bounds, surface, geo);
  
   s->setSurfaceType(surfaceType);
   s->setTranslation(translation);
   s->setRotation(rotation);
   s->setBoundValues(bounds);
 }

◆ encodeSurface() [3/3]

void ActsTrk::encodeSurface	(	xAOD::TrackSurfaceAuxContainer *	backend,
		size_t	index,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

Prepares persistifiable representation of surface into xAOD::TrackSurface object.

Warning

supports only few types, unhandled surface type results in a exception

backend - container to store surface data
index - index under which the data needs to be recorded

Definition at line 55 of file SurfaceEncoding.cxx.

                                                    {
   encodeSurface(s->surfaceType[i], s->translation[i], s->rotation[i],
                 s->boundValues[i], surface, geo);
 }

◆ expectedLayerPattern()

std::array< unsigned int, 4 > ActsTrk::expectedLayerPattern	(	const EventContext &	ctx,
		const IActsExtrapolationTool &	extrapolator,
		Acts::BoundTrackParameters	perigee_parameters,
		const Acts::CylinderSurface &	extrapolation_volume
	)

Extrapolate from the perigee outwards and gather information which detector layers should have hits.

Parameters

ctx	the current athena EvetContext @paran extrapolator referece to the Acts extrapolation tool
perigee_parameters	the Acts defining track parameters (parameters at the perigee).
extrapolation_volume	the volume around the perigee which is considered (e.g. pixel detector volume).

Returns: array of layer pattern words: two pairs for pixel and strips containing the barrel and end caps bit pattern with one bit per detector layer. Will extrapolate from the perigee to the given cylinder volume surface and gather the layers which are crossed and on which hits are expected.

Definition at line 14 of file ExpectedHitUtils.cxx.

                                                                                                     {
  
       ActsPropagationOutput result = extrapolator.propagationSteps(ctx,
                                                                    perigee_parameters,
                                                                    extrapolation_volume,
                                                                    Acts::Direction::Forward);
       std::array<unsigned int,4> expected_layer_pattern {0u,0u,0u,0u};
       for (const Acts::detail::Step &step : result.first ) {
          // @TODO boundary check ?, does layer number match layer numbering in athena ?
          // @TODO filter out dead modules
          if (step.geoID.sensitive()) {
             if (step.surface && step.surface->associatedDetectorElement()) {
                const ActsDetectorElement *
                   actsDetEl = dynamic_cast<const ActsDetectorElement *>(step.surface->associatedDetectorElement());
                if (actsDetEl) {
                   const InDetDD::SiDetectorElement *
                      detEl = dynamic_cast<const InDetDD::SiDetectorElement *>(actsDetEl->upstreamDetectorElement());
                   if (detEl) {
                      if (detEl->isPixel()) {
                         InDetDD::DetectorType type = detEl->design().type();
                         unsigned int pattern_idx = type==InDetDD::PixelBarrel ? 0 : 1;
                         const PixelID* pixel_id = static_cast<const PixelID *>(detEl->getIdHelper());
                         expected_layer_pattern[pattern_idx] |= (1<< pixel_id->layer_disk(detEl->identify()) );
                      }
                      else if (detEl->isSCT()) {
                         // @TODO SCT/strip layer number should be shifted by total number of pixel layers ...
                         const SCT_ID* sct_id = static_cast<const SCT_ID *>(detEl->getIdHelper());
                         unsigned int pattern_idx = detEl->isBarrel() ? 2 : 3;
                         expected_layer_pattern[pattern_idx] |= (1<< sct_id->layer_disk(detEl->identify()) );
                      }
                   }
                }
             }
          }
       }
       return expected_layer_pattern;
    }

◆ gatherTrackSummaryData()

void ActsTrk::gatherTrackSummaryData	(	const ActsTrk::TrackContainer &	tracksContainer,
		const typename ActsTrk::TrackContainer::ConstTrackProxy &	track,
		const std::array< const InDetDD::SiDetectorElementCollection *, to_underlying(xAOD::UncalibMeasType::nTypes)> &	siDetEleColl,
		const std::array< unsigned short, to_underlying(xAOD::UncalibMeasType::nTypes)> &	measurement_to_summary_type,
		SumOfValues &	chi2_stat_out,
		HitSummaryData &	hit_info_out,
		std::vector< ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > &	param_state_idx_out,
		std::array< std::array< uint8_t, to_underlying(HitCategory::N)>, to_underlying(xAOD::UncalibMeasType::nTypes)> &	special_hit_counts_out
	)

Helper to gather track summary information from the track states of the specified track.

Parameters

tracksContainer	the Acts track container
track	a track of the given acts track container for which the summary information is to be gathered
siDetEleColl	array of SiDetectorElement collections per measurement type.
measurement_to_summary_type	a LUT to map measurement types to the corresponding summary type for the measurement counts
chi2_stat_out	output of the per track state chi-squared sums and squared sums to compute the per state chi2 variance.
hit_info_out	output of the gathered measurement statistics per detector region, layer, ... .
param_state_idx_out	output vector to be filled with the state index of all track states which are not holes.
special_hit_counts_out	arrays to count holes (and @TODO dead sensors) per measurement type.

Definition at line 16 of file HitSummaryDataUtils.cxx.

   {
      chi2_stat_out.reset();
  
      hit_info_out.reset();
      param_state_idx_out.clear();
  
      const auto lastMeasurementIndex = track.tipIndex();
      tracksContainer.trackStateContainer().visitBackwards(
           lastMeasurementIndex,
           [&siDetEleColl,
            &measurement_to_summary_type,
            &chi2_stat_out,
            &hit_info_out,
            &param_state_idx_out,
            &special_hit_counts_out
            ](const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy &state) -> void
           {
  
              auto flag = state.typeFlags();
              if (flag.test(Acts::TrackStateFlag::HoleFlag)) {
                 xAOD::UncalibMeasType det_type = xAOD::UncalibMeasType::Other;
                 if (state.hasReferenceSurface()) {
                    if (state.referenceSurface().associatedDetectorElement()) {
                       const ActsDetectorElement *
                          actsDetEl = dynamic_cast<const ActsDetectorElement *>(state.referenceSurface().associatedDetectorElement());
                       if (actsDetEl) {
                          const InDetDD::SiDetectorElement *
                             detEl = dynamic_cast<const InDetDD::SiDetectorElement *>(actsDetEl->upstreamDetectorElement());
                          if (detEl) {
                             if (detEl->isPixel()) {
                                det_type = xAOD::UncalibMeasType::PixelClusterType;
                             }
                             else if (detEl->isSCT()) {
                                det_type = xAOD::UncalibMeasType::StripClusterType;
                          }
                          }
                       }
                    }
                 }
  
                 Acts::BoundaryCheck bcheck(//check local0 ?
                                            (det_type == xAOD::UncalibMeasType::PixelClusterType
                                             || state.referenceSurface().bounds().type() != Acts::SurfaceBounds::eAnnulus),
                                            // check local1
                                            (det_type == xAOD::UncalibMeasType::PixelClusterType
                                             || state.referenceSurface().bounds().type() == Acts::SurfaceBounds::eAnnulus)
                                            // @TODO tolerances ?
                                            );
                 Acts::Vector2 localPos(state.predicted()[Acts::eBoundLoc0],state.predicted()[Acts::eBoundLoc1]);
                 if (state.referenceSurface().insideBounds(localPos,bcheck)) {
                    // @TODO check whether detector element is dead..
                    // if (dead) {
                    // ++specialHitCounts.at(to_underlying(det_type)).at(HitCategory::DeadSensor);
                    // } else {
                    ++special_hit_counts_out.at(to_underlying(det_type)).at(HitCategory::Hole);
                 }
  
              }
              else if (flag.test(Acts::TrackStateFlag::MeasurementFlag)) {
                 // do not consider material states
                 param_state_idx_out.push_back(state.index());
              }
              // @TODO dead elements
  
              if (state.hasUncalibratedSourceLink()) {
                 auto sl = state.getUncalibratedSourceLink().template get<ActsTrk::ATLASUncalibSourceLink>();
                 assert( sl.isValid() && *sl);
                 const xAOD::UncalibratedMeasurement &uncalibMeas = getUncalibratedMeasurement(sl);
                 if (measurement_to_summary_type.at(to_underlying(uncalibMeas.type())) <  xAOD::numberOfTrackSummaryTypes ) {
                    if (static_cast<unsigned int>(to_underlying(uncalibMeas.type())) < siDetEleColl.size()) {
                       hit_info_out.addHit(siDetEleColl[to_underlying(uncalibMeas.type())],
                                           uncalibMeas.identifierHash(),
                                           (flag.test(Acts::TrackStateFlag::OutlierFlag)
                                            ? HitSummaryData::Outlier
                                            : HitSummaryData::Hit));
                    }
                 }
                 if (state.calibratedSize()>0 && !flag.test(Acts::TrackStateFlag::OutlierFlag)) {
                    // from Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx
                    //       processTrackState
                    double chi2add = std::min(state.chi2(),1e5f) / state.calibratedSize();
                    chi2_stat_out.add(chi2add );
                 }
              }
  
           });
      hit_info_out.computeSummaries();
   }

◆ getDepositedEnergy()

template<class T_Deposit >

float ActsTrk::getDepositedEnergy ( const T_Deposit & )

◆ getInTruthPropertyName()

template<class T_TruthEventCollection >

const char* ActsTrk::getInTruthPropertyName ( )

inline

◆ getRDOList()

template<class T >

auto ActsTrk::getRDOList ( const T & a )

Definition at line 109 of file MeasurementToTruthAssociationAlg.h.

                               {
      if constexpr(has_rdoList<T>::value) {
         return a.rdoList();
      }
      else {
         return DummyRDOList(a);
      }
   }

◆ getSimDataDeposits()

template<class T_SimDataCollection , class T_SimDataIterator >

auto ActsTrk::getSimDataDeposits	(	const T_SimDataCollection &	sim_data_collection,
		T_SimDataIterator	sim_data_iter_for_identifier
	)

◆ getUncalibratedMeasurement()

const xAOD::UncalibratedMeasurement& ActsTrk::getUncalibratedMeasurement ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 27 of file ATLASSourceLink.h.

                                                                                                                    {
       assert(source_link);
       return *source_link;
    }

◆ localXFromSourceLink()

float ActsTrk::localXFromSourceLink ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 54 of file ATLASSourceLink.h.

                                                                                 {
       const xAOD::UncalibratedMeasurement &uncalib_meas = getUncalibratedMeasurement(source_link);
       return uncalib_meas.type() == xAOD::UncalibMeasType::PixelClusterType
          ? uncalib_meas.localPosition<2>()[Trk::locX]
          : uncalib_meas.localPosition<1>()[Trk::locX];
    }

◆ localYFromSourceLink()

float ActsTrk::localYFromSourceLink ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 61 of file ATLASSourceLink.h.

                                                                                 {
       const xAOD::UncalibratedMeasurement &uncalib_meas = getUncalibratedMeasurement(source_link);
       assert(uncalib_meas.type() == xAOD::UncalibMeasType::PixelClusterType );
       return uncalib_meas.localPosition<2>()[Trk::locY];
    }

◆ makeATLASUncalibSourceLink() [1/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink	(	[[maybe_unused] ] const xAOD::UncalibratedMeasurementContainer *	container,
		const xAOD::UncalibratedMeasurement *	measurement,
		[[maybe_unused] ] const EventContext &	ctx
	)

inline

Definition at line 37 of file ATLASSourceLink.h.

                                                                                                       {
       assert( container == measurement->container());
       assert( container && measurement->index() < container->size() );
       return measurement;
    }

◆ makeATLASUncalibSourceLink() [2/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink ( const xAOD::UncalibratedMeasurement * measurement )

inline

Definition at line 50 of file ATLASSourceLink.h.

                                                                                                             {
       assert(measurement && measurement->container() && measurement->index() < measurement->container()->size_v());
       return measurement;
    }

◆ makeATLASUncalibSourceLink() [3/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink	(	const xAOD::UncalibratedMeasurementContainer *	container,
		std::size_t	index
	)

inline

Definition at line 44 of file ATLASSourceLink.h.

                                                                              {
       assert(container && index < container->size());
       return container->at(index);
    }

◆ makeATLASUncalibSourceLink() [4/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink	(	const xAOD::UncalibratedMeasurementContainer *	container,
		std::size_t	index,
		[[maybe_unused] ] const EventContext &	ctx
	)

inline

Definition at line 31 of file ATLASSourceLink.h.

                                                                                                       {
       assert(container && index < container->size());
       return container->at(index);
    }

◆ makeDepositToTruthParticleMap()

template<class T_TruthEventCollection >

auto ActsTrk::makeDepositToTruthParticleMap ( const T_TruthEventCollection * truth_particle_links )

◆ makeInterfaceContainer()

template<typename IFACE , typename AUX >

std::unique_ptr<IFACE> ActsTrk::makeInterfaceContainer ( const AUX * aux )

helper to construct interface container for already filled Aux container TODO maybe should be moved to xAOD area

Definition at line 490 of file MultiTrajectory.h.

                                                             {
   auto interface = std::make_unique<IFACE>();
   for ( size_t i = 0, sz = aux->size(); i < sz; ++i) {
     interface->emplace_back( new std::remove_pointer_t<typename IFACE::value_type>() );
   }
   interface->setStore(aux);
   return interface;
 }

◆ operator<() [1/3]

bool ActsTrk::operator<	(	const IdentifierHash &	a,
		const std::unique_ptr< SurfaceCache > &	b
	)

inline

Definition at line 57 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                                                        {
       return a < b->hash();
   }

◆ operator<() [2/3]

bool ActsTrk::operator<	(	const std::unique_ptr< SurfaceCache > &	a,
		const IdentifierHash &	b
	)

inline

Definition at line 60 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                                                        {
       return a->hash() < b;
   }

◆ operator<() [3/3]

bool ActsTrk::operator<	(	const std::unique_ptr< SurfaceCache > &	a,
		const std::unique_ptr< SurfaceCache > &	b
	)

inline

Comparison operators.

Definition at line 53 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                               {
       return a->hash() < b->hash();
   }

◆ operator<<()

MsgStream & ActsTrk::operator<<	(	MsgStream &	out,
		const ActsUtils::Stat &	stat
	)

inline

Definition at line 125 of file TrackFindingValidationAlg.cxx.

                                                                           {
      ActsUtils::dumpStat(out, stat);
      return out;
   }

◆ prefixFromTrackContainerName()

std::string ActsTrk::prefixFromTrackContainerName ( const std::string & tracks )

Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks, the XYZ is returned.

Definition at line 13 of file TrackContainerHandlesHelper.cxx.

                                                                 {
   std::regex word_regex("(.*)Tracks$");
   std::smatch match_regex;
   
   if ( not std::regex_search(tracks, match_regex, word_regex) or match_regex.size() < 2) {
     throw std::runtime_error(
        std::string("prefixFromTrackContainerName: key does not contain "
            "Tracks in the name ") + tracks);
   }
  
   return match_regex[1].str();
 }

◆ recordxAOD()

template<typename T , typename IFACE , typename AUX >

void ActsTrk::recordxAOD	(	const SG::WriteHandleKey< T > &	key,
		IFACE &	iface,
		AUX &	aux,
		const EventContext &	context
	)

Definition at line 27 of file TrackContainerHandlesHelper.cxx.

                                              {
   SG::WriteHandle<T> handle = SG::makeHandle(key, context);
   if (handle.record(std::move(iface), std::move(aux)).isFailure()) {
     throw std::runtime_error(
         std::string("MutableTrackContainerHandlesHelper::recordxAOD, can't record ") + key.key() + " backend");
   }
 }

◆ to_string()

std::string ActsTrk::to_string ( const DetectorType & type )

inline

Definition at line 34 of file GeometryDefs.h.

                                                          {
         if (type == DetectorType::Pixel)
             return "Pixel";
         else if (type == DetectorType::Sct)
             return "Sct";
         else if (type == DetectorType::Trt)
             return "Trt";
         else if (type == DetectorType::Hgtd)
             return "Hgtd";
         else if (type == DetectorType::Mdt)
             return "Mdt";
         else if (type == DetectorType::Rpc)
             return "Rpc";
         else if (type == DetectorType::Tgc)
             return "Tgc";
         else if (type == DetectorType::Csc)
             return "Csc";
         else if (type == DetectorType::Mm)
             return "Mm";
         else if (type == DetectorType::sTgc)
             return "sTgc";
         return "Unknown";
     }

◆ to_underlying()

template<typename T_EnumClass >

constexpr std::underlying_type<T_EnumClass>::type ActsTrk::to_underlying ( T_EnumClass an_enum )

constexpr

Helper to convert class enum into an integer.

Definition at line 24 of file HitSummaryDataUtils.h.

                                                                                              {
       return static_cast<typename std::underlying_type<T_EnumClass>::type>(an_enum);
    }

Variable Documentation

◆ NHitCounter

constexpr unsigned int ActsTrk::NHitCounter = static_cast< std::underlying_type<xAOD::UncalibMeasType>::type >(xAOD::UncalibMeasType::nTypes) - 1u

constexpr

Definition at line 17 of file TrackToTruthParticleAssociation.h.

◆ NTruthParticlesPerMeasurement

constexpr unsigned int ActsTrk::NTruthParticlesPerMeasurement = 5

constexpr

Definition at line 9 of file MeasurementToTruthParticleAssociation.h.

◆ NTruthParticlesPerTrack

constexpr unsigned int ActsTrk::NTruthParticlesPerTrack = 5

constexpr

Definition at line 18 of file TrackToTruthParticleAssociation.h.

◆ ONE_TWELFTH

constexpr double ActsTrk::ONE_TWELFTH = 1./12.

constexpr

Definition at line 17 of file StripClusteringTool.cxx.

◆ TrackFindingValidationDebugHists

constexpr bool ActsTrk::TrackFindingValidationDebugHists = false

constexpr

Definition at line 43 of file TrackFindingValidationAlg.h.

◆ TrackToTruthParticleAssociationDebugHists

constexpr bool ActsTrk::TrackToTruthParticleAssociationDebugHists = false

constexpr

Definition at line 42 of file TrackToTruthAssociationAlg.h.

◆ TruthParticleHitCountDebugHists

constexpr bool ActsTrk::TruthParticleHitCountDebugHists = false

constexpr

Definition at line 42 of file TruthParticleHitCountAlg.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ATLASSourceLink

◆ ATLASUncalibSourceLink

◆ BoundTrackParametersContainer

◆ ConstCovariance

◆ ConstParameters

◆ Covariance

◆ IndexType

◆ MeasurementToTruthParticleAssociation

◆ MutableTrackBackend

◆ MutableTrackStateBackend

◆ Parameters

◆ ParticleVector

◆ rdoListFunc_t

◆ ReturnedHintArr

◆ ReturnedTicketArr

◆ Seed

◆ SeedContainer

◆ StoredSurface

◆ StripRDORawData

◆ SurfaceBoundSetPtr

◆ SurfaceCacheSet

◆ TicketCounterArr

◆ TrackBackend

◆ TrackContainerBase

◆ TrackStateBackend

◆ TrackToTruthParticleAssociation

◆ TruthParticleHitCounts

Enumeration Type Documentation

◆ DetectorType

◆ NeighbourIndices

Function Documentation

◆ actsLevelVector()

◆ athLevelVector()

◆ clusterAddCell()

◆ computeDtDs()

◆ computeFreeToPathDerivatives()

◆ convertActsBoundCovToCurvilinearParam()

◆ decodeSurface() [1/3]

◆ decodeSurface() [2/3]

◆ decodeSurface() [3/3]

◆ encodeSurface() [1/3]

◆ encodeSurface() [2/3]

◆ encodeSurface() [3/3]

◆ expectedLayerPattern()

◆ gatherTrackSummaryData()

◆ getDepositedEnergy()

◆ getInTruthPropertyName()

◆ getRDOList()

◆ getSimDataDeposits()

◆ getUncalibratedMeasurement()

◆ localXFromSourceLink()

◆ localYFromSourceLink()

◆ makeATLASUncalibSourceLink() [1/4]

◆ makeATLASUncalibSourceLink() [2/4]

◆ makeATLASUncalibSourceLink() [3/4]

◆ makeATLASUncalibSourceLink() [4/4]

◆ makeDepositToTruthParticleMap()

◆ makeInterfaceContainer()

◆ operator<() [1/3]

◆ operator<() [2/3]

◆ operator<() [3/3]

◆ operator<<()

◆ prefixFromTrackContainerName()

◆ recordxAOD()

◆ to_string()

◆ to_underlying()

Variable Documentation

◆ NHitCounter

◆ NTruthParticlesPerMeasurement

◆ NTruthParticlesPerTrack

◆ ONE_TWELFTH

◆ TrackFindingValidationDebugHists