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
	Athena definition of the Eigen plugin.

	details

	ParticleHypothesis

	ScoreBasedSolverCutsImpl

Classes
class	ActsInspectTruthContentAlg

class	ActsSeed

class	ActsToTrkConverterTool

class	ActsToTrkConvertorAlg

class	ActsToXAODTrackConverterAlg

class	ActsTrackStateOnSurfaceDecoratorAlg

class	ActsVolumeIdToDetectorElementCollectionMap

class	ActsVolumeIdToDetectorElementCollectionMappingAlg

class	AdaptiveMultiPriVtxFinderTool

class	AlignStoreProviderAlg

class	AmbiguityResolutionAlg

class	AuxiliaryMeasurementHandler
	Utility class to handle the creation of the Auxiliary measurement used in an Acts track fit This class declares the additionally written xAOD::AuxiliaryMeasurementContainers to the AvalancheScheduler. More...

class	CaloBasedRoICreatorTool

class	ClusterizationAlg

class	ConstTrackContainerHandlesHelper

class	CoreStripSpacePointFormationTool

struct	DataLinkHolder

class	DataPreparationAlg

class	DetectorAlignCondAlg

class	DetectorAlignStore

struct	DetectorElementToActsGeometryIdMap

class	DetectorVolumeSvc

class	DummyRDOList

class	EstimatedTrackParamsAnalysisAlg

class	FullScanRoICreatorTool

class	GaussianSumFitterTool

class	GbtsSeedingTool

class	GeometryContextAlg

class	GlobalChiSquareFitterTool

class	GridTripletSeedingAlg

class	GridTripletSeedingTool

struct	has_rdoList

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

class	HgtdClusterAnalysisAlg

class	HgtdClusterDataPreparationAlg

class	HgtdClusteringTool

class	HgtdClusterizationAlg

class	HgtdClusterToTruthAssociationAlg

class	HgtdClusterValidationPlots

class	HgtdTimedClusteringTool

class	HGTDTrackExtensionAlg

class	HGTDTruthTrackDecorationAlg

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	IActsToTrkConverterTool
	Conversion tool interface to translate surfaces & track parameters between the Acts & Trk realm. More...

class	IBlueprintNodeBuilder
	Interface for the Blueprint node builder This interface is used to build a Blueprint node for the Acts tracking geometry. More...

class	IDetectorElement
	Base class interface for the actual readout elements. More...

class	IDetectorElementBase
	base class interface providing the bare minimal interface extension. More...

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
	Generic interface class to fit xAOD::Uncalibrated measurements to (multi)-trajectories. More...

class	IHGTDClusteringTool

class	IMeasurementSelector

class	IndexingPolicy

class	IOnBoundStateCalibratorTool

class	IOnTrackCalibratorTool

class	IPixelClusteringTool

class	IPixelSpacePointFormationTool

class	IProtoTrackCreatorTool

class	IRoICreatorTool

class	ISeedingTool

class	IStripClusteringTool

class	IStripSpacePointFormationTool

class	IterativePriVtxFinderTool

class	ITkAlignMonResidualsAlg

class	ITkAnalogueClusteringTool

class	ItkBlueprintNodeBuilder
	Helper class to build the ItkBlueprint node It adds the system as a node to the Blueprint. More...

class	ITrackingGeometryTool
	Geometry helper tool extending the Tracking geometry service by the data dependency to fetch the geometry context from StoreGate. More...

class	ITrackParamsEstimationTool

class	KalmanFitterTool

struct	MeasurementCalibrator

struct	MeasurementParameterMap

class	MeasurementToTrackParticleDecorationAlg

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	MeasurementToTruthParticleAssociation

class	MSTrackingVolumeBuilder

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	MuonBlueprintNodeBuilder
	Helper class to build a Blueprint node of the muon system. More...

class	MuonDetectorBuilderTool

class	MuonDetectorNavTest

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

struct	MutablePersistentTrackContainer

class	MutableTrackContainerHandlesHelper

class	MutableTrackSummaryContainer

class	NoDeletePtr

class	OrthogonalSeedingTool

class	PersistentTrackContainer

class	PhysValTool

class	PixelCacheClusterizationAlg

class	PixelCacheSpacePointFormationAlg

class	PixelClusterAnalysisAlg

class	PixelClusterCacheDataPreparationAlg

class	PixelClusterDataPreparationAlg

class	PixelClusteringTool

class	PixelClusterizationAlg

class	PixelClusterSiHitDecoratorAlg

class	PixelClusterToTruthAssociationAlg

class	PixelClusterTruthDecoratorAlg

class	PixelClusterValidationPlots

class	PixelSpacePointFormationAlg

class	PixelSpacePointFormationAlgBase

class	PixelSpacePointFormationTool

class	PixelSpacePointValidationPlots

class	PrdAssociationAlg

class	PrepRawDataAssociation

struct	ProtoTrack

class	ProtoTrackCreationAndFitAlg

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

class	RandomProtoTrackCreatorTool

class	ReFitterAlg

class	RegionsOfInterestCreatorAlg

class	ScoreBasedAmbiguityResolutionAlg

class	SeedAnalysisAlg

class	SeedingAlg

class	SeedingAlgorithmAnalysisAlg

class	SeedingTool

class	SeedsToTrackParamsAlg

class	SeedToTrackAnalysisAlg

class	SeedToTrackCnvAlg

class	SimpleCylinderDetBuilderTool

class	SiSpacePointsSeedMaker

class	SpacePointAnalysisAlg

class	SpacePointCacheDataPreparationAlg

class	SpacePointCollector

class	SpacePointDataPreparationAlg

class	StripCacheClusterizationAlg

class	StripCacheSpacePointFormationAlg

class	StripClusterAnalysisAlg

class	StripClusterCacheDataPreparationAlg

class	StripClusterDataPreparationAlg

class	StripClusteringTool

class	StripClusterizationAlg

class	StripClusterSiHitDecoratorAlg

class	StripClusterToTruthAssociationAlg

class	StripClusterTruthDecoratorAlg

class	StripClusterValidationPlots

class	StripInformationHelper

struct	StripSP

class	StripSpacePointFormationAlg

class	StripSpacePointFormationAlgBase

class	StripSpacePointFormationTool

class	StripSpacePointValidationPlots

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	TrackExtensionAlg

class	TrackFindingAlg

class	TrackFindingBaseAlg

class	TrackFindingValidationAlg

class	TrackParamsEstimationTool

class	TrackParticleAnalysisAlg

class	TrackParticleTruthDecorationAlg

class	TrackStatePrinterTool

class	TrackSummaryContainer

class	TrackToTrackParticleCnvAlg

class	TrackToTruthAssociationAlg

class	TrackToTruthParticleAssociation

class	TrackTruthMatchingBaseAlg

class	TransformCache

class	TransformCacheDetEle

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

class	TruthGuidedProtoTrackCreatorTool

class	TruthParticleHitCountAlg

Typedefs
using	staticNodePtr = std::shared_ptr< Acts::Experimental::StaticBlueprintNode >

using	surfacePtr = std::shared_ptr< Acts::Surface >

using	MuonChamberSet = MuonGMR4::MuonDetectorManager::MuonChamberSet

using	MuonSectorSet = MuonGMR4::MuonDetectorManager::MuonSectorSet

using	StIdx = Muon::MuonStationIndex::StIndex

using	volumePtr = std::shared_ptr< DetectorVolume >

using	StripLayerPtr = GeoModel::TransientConstSharedPtr< MuonGMR4::StripLayer >

using	IndexType = std::uint32_t

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

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

using	MutablePersistentTrackBackend = ActsTrk::MutableTrackSummaryContainer

using	PersistentTrackBackend = ActsTrk::TrackSummaryContainer

using	MutablePersistentTrackStateBackend = ActsTrk::MutableMultiTrajectory

using	PersistentTrackStateBackend = ActsTrk::MultiTrajectory

using	PersistentTrackContainerBase = Acts::TrackContainer< ActsTrk::PersistentTrackBackend, ActsTrk::PersistentTrackStateBackend, ActsTrk::DataLinkHolder >

typedef std::vector< ActsTrk::ProtoTrack >	ProtoTrackCollection

typedef ActsSeed< xAOD::SpacePoint, 3ul >	Seed

typedef DataVector< ActsTrk::Seed >	SeedContainer

using	TrackBackend = Acts::ConstVectorTrackContainer

using	MutableTrackBackend = Acts::VectorTrackContainer

using	TrackStateBackend = Acts::ConstVectorMultiTrajectory

using	MutableTrackStateBackend = Acts::VectorMultiTrajectory

using	TrackContainerBase = Acts::TrackContainer< TrackBackend, TrackStateBackend, Acts::detail::ValueHolder >

using	MutableTrackContainer = Acts::TrackContainer< MutableTrackBackend, MutableTrackStateBackend, Acts::detail::ValueHolder >

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	TruthParticleHitCounts = std::unordered_map< const xAOD::TruthParticle *, HitCounterArray >

using	ATLASSourceLink = const Trk::MeasurementBase *

using	ATLASUncalibSourceLink = const xAOD::UncalibratedMeasurement *

using	DetectorElementKey = unsigned int

using	TicketCounterArr = DetectorAlignStore::TrackingAlignStore::TicketCounterArr

using	ReturnedTicketArr = DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr

using	ReturnedHintArr = DetectorAlignStore::TrackingAlignStore::ReturnedHintArr

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

using	AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor

using	DefaultTrackStateCreator = Acts::TrackStateCreator< ActsTrk::detail::UncalibSourceLinkAccessor::Iterator, detail::RecoTrackContainer >

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
std::string	objFileName (std::string str)

Acts::CalibrationContext	getCalibrationContext (const EventContext &ctx)
	The Acts::Calibration context is piped through the Acts fitters to (re)calibrate the Acts::SourceLinks during the track State upate. More...

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

template<typename... args_t>
	requires (sizeof...(args_t)==N) &&(std

template<typename arg_t >
	requires (N !=1) ActsSeed< external_spacepoint_t

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

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)

DetectorElementKey	makeDetectorElementKey (xAOD::UncalibMeasType meas_type, unsigned int identifier_hash)

Acts::GeometryIdentifier	getSurfaceGeometryIdOfMeasurement (const DetectorElementToActsGeometryIdMap &detector_element_to_geoid, const xAOD::UncalibratedMeasurement &measurement)

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)

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)
	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)
	As above, but takes data from Aux container at an index i. 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)

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

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

constexpr double	energyToActs (const double athenaE)
	Converts an energy scalar from Athena to Acts units. More...

constexpr double	energyToAthena (const double actsE)
	Converts an energy scalar from Acts to Athena units. More...

constexpr double	lengthToActs (const double athenaL)
	Converts a length scalar from Acts to Athena units. More...

constexpr double	lengthToAthena (const double actsL)
	Converts a length scalar from Acts to Athena units. More...

constexpr double	timeToActs (const double athenaT)
	Converts a time unit from Athena to Acts units. More...

constexpr double	timeToAthena (const double actsT)
	Converts a time unit from Acts to Athena units. More...

Acts::Vector3	convertDirToActs (const Amg::Vector3D &athenaDir)
	Converts a direction vector from athena units into acts units. More...

Amg::Vector3D	convertDirFromActs (const Acts::Vector3 &actsDir)
	Converts a direction vector from acts units into athena units. More...

Acts::Vector4	convertPosToActs (const Amg::Vector3D &athenaPos, const double athenaTime=0.)
	Converts a position vector & time from Athena units into Acts units. More...

std::pair< Amg::Vector3D, double >	convertPosFromActs (const Acts::Vector4 &actsPos)
	Converts an Acts 4-vector into a pair of an Athena spatial vector and the passed time. More...

Acts::Vector4	convertMomToActs (const Amg::Vector3D &threeMom, const double mass=0.)
	Converts a three momentum vector from Athena together with the associated particle mass into an Acts four-momentum vector. More...

std::pair< Amg::Vector3D, double >	convertMomFromActs (const Acts::Vector4 &actsMom)
	Converts an Acts four-momentum vector into an pair of an Athena three-momentum and the paritcle's energy. More...

template<typename T >
std::underlying_type_t< T >	to_underlying (T val)

template<class T_Cont , class T >
std::vector< SG::WriteDecorHandle< T_Cont, T > >	createDecorators (const std::vector< SG::WriteDecorHandleKey< T_Cont > > &keys, const EventContext &ctx)

template<class T_Parent , class T_Cont >
void	createDecoratorKeys (T_Parent &parent, const SG::ReadHandleKey< T_Cont > &container_key, const std::string &prefix, const std::vector< std::string > &decor_names, std::vector< SG::WriteDecorHandleKey< T_Cont > > &decor_out)

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)

constexpr unsigned int	NTruthParticlesPerTrack = 5

constexpr unsigned int	DETELEMENT_TYPE_SHIFT = 28

constexpr unsigned int	DETELEMENT_HASH_MASK = ~(1u<<31\|1u<<30\|1u<<29\|1u<<28)

constexpr bool	TrackToTruthParticleAssociationDebugHists = false

constexpr bool	TrackFindingValidationDebugHists = false

constexpr bool	TrackFindingValidationDetailedStat = true

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

copied from InDetPhysValMonitoring/src/safeDecorator.h

Put athena Eigen inlcude first.

: The NoDeletePtr is a shared_ptr with disabled deleter.

Header file to manage the common inlcudes.

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.

forward declarations of the classes defined in the package

Typedef Documentation

◆ ATLASSourceLink

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

Definition at line 23 of file ATLASSourceLink.h.

◆ ATLASUncalibSourceLink

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

Definition at line 24 of file ATLASSourceLink.h.

◆ AtlUncalibSourceLinkAccessor

using ActsTrk::AtlUncalibSourceLinkAccessor = typedef detail::UncalibSourceLinkAccessor

Definition at line 43 of file TrackFindingAlg.h.

◆ BoundTrackParametersContainer

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

Definition at line 12 of file Tracking/Acts/ActsEvent/ActsEvent/TrackParametersContainer.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.

◆ DefaultTrackStateCreator

using ActsTrk::DefaultTrackStateCreator = typedef Acts::TrackStateCreator<ActsTrk::detail::UncalibSourceLinkAccessor::Iterator,detail::RecoTrackContainer>

Definition at line 44 of file TrackFindingAlg.h.

◆ DetectorElementKey

using ActsTrk::DetectorElementKey = typedef unsigned int

Definition at line 19 of file DetectorElementToActsGeometryIdMap.h.

◆ IndexType

typedef std::uint32_t ActsTrk::IndexType

Definition at line 14 of file Decoration.h.

◆ MuonChamberSet

using ActsTrk::MuonChamberSet = typedef MuonGMR4::MuonDetectorManager::MuonChamberSet

Definition at line 42 of file MuonBlueprintNodeBuilder.h.

◆ MuonSectorSet

using ActsTrk::MuonSectorSet = typedef MuonGMR4::MuonDetectorManager::MuonSectorSet

Definition at line 43 of file MuonBlueprintNodeBuilder.h.

◆ MutablePersistentTrackBackend

using ActsTrk::MutablePersistentTrackBackend = typedef ActsTrk::MutableTrackSummaryContainer

Definition at line 14 of file PersistentTrackContainer.h.

◆ MutablePersistentTrackStateBackend

using ActsTrk::MutablePersistentTrackStateBackend = typedef ActsTrk::MutableMultiTrajectory

Definition at line 16 of file PersistentTrackContainer.h.

◆ MutableTrackBackend

using ActsTrk::MutableTrackBackend = typedef Acts::VectorTrackContainer

Definition at line 15 of file TrackContainer.h.

◆ MutableTrackContainer

using ActsTrk::MutableTrackContainer = typedef Acts::TrackContainer<MutableTrackBackend, MutableTrackStateBackend, Acts::detail::ValueHolder>

Definition at line 24 of file TrackContainer.h.

◆ MutableTrackStateBackend

using ActsTrk::MutableTrackStateBackend = typedef Acts::VectorMultiTrajectory

Definition at line 17 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 17 of file MeasurementToTruthParticleAssociation.h.

◆ PersistentTrackBackend

using ActsTrk::PersistentTrackBackend = typedef ActsTrk::TrackSummaryContainer

Definition at line 15 of file PersistentTrackContainer.h.

◆ PersistentTrackContainerBase

using ActsTrk::PersistentTrackContainerBase = typedef Acts::TrackContainer<ActsTrk::PersistentTrackBackend, ActsTrk::PersistentTrackStateBackend, ActsTrk::DataLinkHolder>

Definition at line 28 of file PersistentTrackContainer.h.

◆ PersistentTrackStateBackend

using ActsTrk::PersistentTrackStateBackend = typedef ActsTrk::MultiTrajectory

Definition at line 17 of file PersistentTrackContainer.h.

◆ ProtoTrackCollection

typedef std::vector<ActsTrk::ProtoTrack> ActsTrk::ProtoTrackCollection

Definition at line 12 of file ProtoTrackCollection.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 ActsSeed<xAOD::SpacePoint, 3ul> ActsTrk::Seed

Definition at line 87 of file Seed.h.

◆ SeedContainer

typedef DataVector<ActsTrk::Seed> ActsTrk::SeedContainer

Definition at line 12 of file SeedContainer.h.

◆ staticNodePtr

using ActsTrk::staticNodePtr = typedef std::shared_ptr<Acts::Experimental::StaticBlueprintNode>

Definition at line 40 of file MuonBlueprintNodeBuilder.h.

◆ StIdx

using ActsTrk::StIdx = typedef Muon::MuonStationIndex::StIndex

Definition at line 44 of file MuonBlueprintNodeBuilder.h.

◆ StoredSurface

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

Definition at line 66 of file MultiTrajectory.h.

◆ StripLayerPtr

using ActsTrk::StripLayerPtr = typedef GeoModel::TransientConstSharedPtr<MuonGMR4::StripLayer>

Definition at line 65 of file MuonDetectorBuilderTool.cxx.

◆ SurfaceCacheSet

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

Definition at line 18 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/Defs.h.

◆ surfacePtr

typedef std::shared_ptr< Acts::Surface > ActsTrk::surfacePtr

Definition at line 41 of file MuonBlueprintNodeBuilder.h.

◆ TicketCounterArr

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

Definition at line 14 of file DetectorAlignStore.cxx.

◆ TrackBackend

using ActsTrk::TrackBackend = typedef Acts::ConstVectorTrackContainer

Definition at line 14 of file TrackContainer.h.

◆ TrackContainerBase

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

Definition at line 20 of file TrackContainer.h.

◆ TrackStateBackend

using ActsTrk::TrackStateBackend = typedef Acts::ConstVectorMultiTrajectory

Definition at line 16 of file TrackContainer.h.

◆ TruthParticleHitCounts

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

Definition at line 19 of file TruthParticleHitCounts.h.

◆ volumePtr

using ActsTrk::volumePtr = typedef std::shared_ptr<DetectorVolume>

Definition at line 63 of file MuonDetectorBuilderTool.cxx.

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

◆ convertDirFromActs()

Amg::Vector3D ActsTrk::convertDirFromActs ( const Acts::Vector3 & actsDir )

inline

Converts a direction vector from acts units into athena units.

Parameters

actsDir Unit normalized vector to convert

Definition at line 68 of file UnitConverters.h.

                                                                       {
         return actsDir;
     }

◆ convertDirToActs()

Acts::Vector3 ActsTrk::convertDirToActs ( const Amg::Vector3D & athenaDir )

inline

Converts a direction vector from athena units into acts units.

Parameters

athenaDir Unit normalized vector to convert

Definition at line 63 of file UnitConverters.h.

                                                                       {
         return athenaDir;
     }

◆ convertMomFromActs()

std::pair<Amg::Vector3D, double> ActsTrk::convertMomFromActs ( const Acts::Vector4 & actsMom )

inline

Converts an Acts four-momentum vector into an pair of an Athena three-momentum and the paritcle's energy.

Parameters

actsMom The four momentum vector from Acts

Definition at line 109 of file UnitConverters.h.

                                                                                        {
         Amg::Vector3D threeMom{Amg::Vector3D::Zero()};
         threeMom[Amg::x] = energyToAthena(actsMom[Acts::eMom0]);
         threeMom[Amg::y] = energyToAthena(actsMom[Acts::eMom1]);
         threeMom[Amg::z] = energyToAthena(actsMom[Acts::eMom2]);
         return std::make_pair(std::move(threeMom), energyToAthena(actsMom[Acts::eEnergy]));
     }

◆ convertMomToActs()

Acts::Vector4 ActsTrk::convertMomToActs	(	const Amg::Vector3D &	threeMom,
		const double	mass = `0.`
	)

inline

Converts a three momentum vector from Athena together with the associated particle mass into an Acts four-momentum vector.

Parameters

threeMom	Three momentum vector in Athena units
mass	Particle's mass in Athena units

Definition at line 97 of file UnitConverters.h.

                                                                                              {
         using namespace Acts::UnitLiterals;
         Acts::Vector4 fourMom{Acts::Vector4::Zero()};
         fourMom[Acts::eEnergy] = energyToActs(std::sqrt(threeMom.dot(threeMom) + mass*mass));
         fourMom[Acts::eMom0] = energyToActs(threeMom.x());
         fourMom[Acts::eMom1] = energyToActs(threeMom.y());
         fourMom[Acts::eMom2] = energyToActs(threeMom.z());
         return fourMom;
     }

◆ convertPosFromActs()

std::pair<Amg::Vector3D, double> ActsTrk::convertPosFromActs ( const Acts::Vector4 & actsPos )

inline

Converts an Acts 4-vector into a pair of an Athena spatial vector and the passed time.

Parameters

actsPos Position from the Acts framework

Definition at line 86 of file UnitConverters.h.

                                                                                        {
         Amg::Vector3D pos{Amg::Vector3D::Zero()};
         pos[Amg::x] = lengthToAthena(actsPos[Acts::ePos0]);
         pos[Amg::y] = lengthToAthena(actsPos[Acts::ePos1]);
         pos[Amg::z] = lengthToAthena(actsPos[Acts::ePos2]);
         return std::make_pair(std::move(pos), timeToAthena(actsPos[Acts::eTime]));
     }

◆ convertPosToActs()

Acts::Vector4 ActsTrk::convertPosToActs	(	const Amg::Vector3D &	athenaPos,
		const double	athenaTime = `0.`
	)

inline

Converts a position vector & time from Athena units into Acts units.

Parameters

athenaPos	3D-spatial position vector to convert
athenaTime	Time counts to convert

Definition at line 74 of file UnitConverters.h.

                                                                        {
         Acts::Vector4 pos{Acts::Vector4::Zero()};
         pos[Acts::eTime] = timeToActs(athenaTime);
         pos[Acts::ePos0] = lengthToActs(athenaPos.x());
         pos[Acts::ePos1] = lengthToActs(athenaPos.y());
         pos[Acts::ePos2] = lengthToActs(athenaPos.z());
         return pos;
     }

◆ createDecoratorKeys()

template<class T_Parent , class T_Cont >

void ActsTrk::createDecoratorKeys	(	T_Parent &	parent,
		const SG::ReadHandleKey< T_Cont > &	container_key,
		const std::string &	prefix,
		const std::vector< std::string > &	decor_names,
		std::vector< SG::WriteDecorHandleKey< T_Cont > > &	decor_out
	)

Definition at line 49 of file decoratorUtils.h.

                                                                                  {
     decor_out.clear();
     decor_out.reserve(decor_names.size());
     for (const std::string &a_decor_name : decor_names) {
       assert( !a_decor_name.empty() );
       decor_out.emplace_back(container_key.key()+"."+prefix+a_decor_name);
       // need to declare handles, otherwise the scheduler would not pick up the data dependencies
       // introduced by the decorations
       parent.declare(decor_out.back());
       decor_out.back().setOwner(&parent);
       decor_out.back().initialize().ignore();
     }
   }

◆ createDecorators()

template<class T_Cont , class T >

std::vector<SG::WriteDecorHandle<T_Cont,T> > ActsTrk::createDecorators	(	const std::vector< SG::WriteDecorHandleKey< T_Cont > > &	keys,
		const EventContext &	ctx
	)

Definition at line 31 of file decoratorUtils.h.

                                               {
     std::vector<SG::WriteDecorHandle<T_Cont,T> > out;
     out.reserve(keys.size());
     for( const SG::WriteDecorHandleKey<T_Cont> &a_key : keys) {
       out.emplace_back(a_key,ctx);
       if (not out.back().isValid()) {
         std::stringstream msg;
         msg << "Failed to create decorator handdle " << a_key.key();
         throw std::runtime_error( msg.str() );
       }
     }
     return out;
   }

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

Definition at line 91 of file SurfaceEncoding.cxx.

                                                                            {
  
   // Translation and rotation
  
   // create the transformation matrix
   Amg::Transform3D transform = 
                    Amg::getTranslate3D(translation[0], translation[1], translation[2]) *
                    Amg::getRotateZ3D(rotation[0]) *
                    Amg::getRotateY3D(rotation[1]) *
                    Amg::getRotateX3D(rotation[2]);
  
   switch (surfaceType) {
       using enum xAOD::SurfaceType;
       case Cone:
         return Acts::Surface::makeShared<Acts::ConeSurface>(std::move(transform), 
                     boundValues[0], boundValues[1], boundValues[2], boundValues[3]);
       case Cylinder: {
         // phi/2 must be slightly < Pi to avoid crashing
         const float fixedPhi = boundValues[2] > M_PI - 0.001 ? M_PI - 0.001 : boundValues[2];
         return Acts::Surface::makeShared<Acts::CylinderSurface>(std::move(transform), 
                 boundValues[0], boundValues[1], fixedPhi, boundValues[3], boundValues[4]);
       } case Disc:
         return Acts::Surface::makeShared<Acts::DiscSurface>(std::move(transform), 
                 boundValues[0], boundValues[1], boundValues[2]);
         case Perigee: 
           return Acts::Surface::makeShared<Acts::PerigeeSurface>(std::move(transform));
         case Plane: {
           Acts::Vector2 min(boundValues[0], boundValues[1]),
                         max(boundValues[2], boundValues[3]);
           auto rBounds = std::make_shared<const Acts::RectangleBounds>(min, max);
           return Acts::Surface::makeShared<Acts::PlaneSurface>(std::move(transform), rBounds);
         } case Straw: 
           return Acts::Surface::makeShared<Acts::StrawSurface>(std::move(transform), 
                                                                boundValues[0], boundValues[1]);
           case Curvilinear:
           case Other: 
             THROW_EXCEPTION("EncodeSurface this type " <<static_cast<int>(surfaceType)<< 
                            " of xAOD::surface cannot be converted into an Acts one");
   }
   
   return nullptr;
 }

◆ decodeSurface() [2/3]

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

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

Definition at line 136 of file SurfaceEncoding.cxx.

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

◆ decodeSurface() [3/3]

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

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

Definition at line 141 of file SurfaceEncoding.cxx.

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

◆ 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 20 of file SurfaceEncoding.cxx.

                                                           {
   // return if surf is a nullptr
   if (!surface) {
     return;
   }
   switch (surface->type()){
      using enum Acts::Surface::SurfaceType;
      case Cone:
         surfaceType = xAOD::SurfaceType::Cone;
         break;
       case Cylinder: 
         surfaceType = xAOD::SurfaceType::Cylinder;
         break;
       case Disc:
         surfaceType = xAOD::SurfaceType::Disc;
         break;
       case Perigee:
         surfaceType = xAOD::SurfaceType::Perigee;
         break;
       case Plane:
         surfaceType = xAOD::SurfaceType::Plane;
         break;
       case Straw: 
         surfaceType = xAOD::SurfaceType::Straw;
         break;
       case Curvilinear:
         surfaceType = xAOD::SurfaceType::Curvilinear;
         break;
       case Other:
         surfaceType = xAOD::SurfaceType::Other;
         break;
   }
  
   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]);
   }
   // copy and transform double->float
   const std::vector<double>& values = surface->bounds().values();
   boundValues.insert(boundValues.end(), values.begin(), values.end());
 }

◆ 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 79 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 72 of file SurfaceEncoding.cxx.

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

◆ energyToActs()

constexpr double ActsTrk::energyToActs ( const double athenaE )

inlineconstexpr

Converts an energy scalar from Athena to Acts units.

Parameters

athenaE Energy value to convert

Definition at line 21 of file UnitConverters.h.

                                                                {
         using namespace Acts::UnitLiterals;
         constexpr double energyCnv = 1_MeV / Gaudi::Units::MeV;
         return energyCnv * athenaE;
     }

◆ energyToAthena()

constexpr double ActsTrk::energyToAthena ( const double actsE )

inlineconstexpr

Converts an energy scalar from Acts to Athena units.

Parameters

athenaE Energy value to convert

Definition at line 28 of file UnitConverters.h.

                                                                {
         using namespace Acts::UnitLiterals;
         constexpr double energyCnv = Gaudi::Units::MeV / 1_MeV;
         return energyCnv * actsE;
     }

◆ getCalibrationContext()

Acts::CalibrationContext ActsTrk::getCalibrationContext ( const EventContext & ctx )

inline

The Acts::Calibration context is piped through the Acts fitters to (re)calibrate the Acts::SourceLinks during the track State upate.

In ATLAS Athena, the EventContext is needed to access the calibration context from the conditions. This function packs the pointer of the current EventContext into a Acts::CalibrationContext

Parameters

ctx	EventContext to transform into a Context

Definition at line 15 of file CalibrationContext.h.

                                                                                 {
         return Acts::CalibrationContext{&ctx};
     }

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

◆ getSurfaceGeometryIdOfMeasurement()

Acts::GeometryIdentifier ActsTrk::getSurfaceGeometryIdOfMeasurement	(	const DetectorElementToActsGeometryIdMap &	detector_element_to_geoid,
		const xAOD::UncalibratedMeasurement &	measurement
	)

inline

Definition at line 13 of file SurfaceOfMeasurementUtil.h.

   {
      DetectorElementToActsGeometryIdMap::const_iterator
         geoid_iter = detector_element_to_geoid.find( makeDetectorElementKey(measurement.type(), measurement.identifierHash()) );
      return  geoid_iter != detector_element_to_geoid.end()
         ? DetectorElementToActsGeometryIdMap::getValue( *geoid_iter)
         : Acts::GeometryIdentifier{};
   }

◆ getUncalibratedMeasurement()

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

inline

Definition at line 26 of file ATLASSourceLink.h.

                                                                                                                    {
       assert(source_link);
       return *source_link;
    }

◆ lengthToActs()

constexpr double ActsTrk::lengthToActs ( const double athenaL )

inlineconstexpr

Converts a length scalar from Acts to Athena units.

Parameters

athenaL Length value to convert

Definition at line 35 of file UnitConverters.h.

                                                                {
         using namespace Acts::UnitLiterals;
          constexpr double lengthCnv = 1_mm / Gaudi::Units::mm;
          return lengthCnv * athenaL;
     }

◆ lengthToAthena()

constexpr double ActsTrk::lengthToAthena ( const double actsL )

inlineconstexpr

Converts a length scalar from Acts to Athena units.

Parameters

athenaL Length value to convert

Definition at line 42 of file UnitConverters.h.

                                                                {
         using namespace Acts::UnitLiterals;
          constexpr double lengthCnv = Gaudi::Units::mm / 1_mm;
          return lengthCnv * actsL;
     }

◆ localXFromSourceLink()

float ActsTrk::localXFromSourceLink ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 53 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 60 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 36 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 49 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 43 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 30 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 )

◆ makeDetectorElementKey()

DetectorElementKey ActsTrk::makeDetectorElementKey	(	xAOD::UncalibMeasType	meas_type,
		unsigned int	identifier_hash
	)

inline

Definition at line 23 of file DetectorElementToActsGeometryIdMap.h.

                                                                                                           {
       assert( sizeof(xAOD::UncalibMeasType) <= sizeof(std::size_t) );
       assert( static_cast<std::size_t>( to_underlying(meas_type)&((~DETELEMENT_HASH_MASK)>>DETELEMENT_TYPE_SHIFT)) == static_cast<std::size_t>(meas_type));
       assert( (identifier_hash & DETELEMENT_HASH_MASK) == identifier_hash);
       return (to_underlying(meas_type) << DETELEMENT_TYPE_SHIFT) | (identifier_hash & DETELEMENT_HASH_MASK);
    }

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

◆ objFileName()

std::string ActsTrk::objFileName ( std::string str )

inline

Definition at line 57 of file MuonDetectorBuilderTool.cxx.

                                                 {
         str = GeoStrUtils::replaceExpInString(str, " ", "_");
         str = GeoStrUtils::replaceExpInString(str, "-", "M");
         return std::format("{:}.obj", str);
     }

◆ operator<() [1/3]

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

inline

Definition at line 63 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 66 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 59 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 25 of file TrackToTruthAssociationAlg.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 20 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();
 }

◆ requires() [1/2]

template<typename arg_t >

ActsTrk::requires ( N ! = 1 )

◆ requires() [2/2]

template<typename... args_t>

ActsTrk::requires ( sizeof... args_t = = N ) &&

Definition at line 50 of file Seed.h.

53 : m_spacepoints({&points...}) {}

◆ timeToActs()

constexpr double ActsTrk::timeToActs ( const double athenaT )

inlineconstexpr

Converts a time unit from Athena to Acts units.

Parameters

athenaT Time interval to convert

Definition at line 49 of file UnitConverters.h.

                                                              {
         using namespace Acts::UnitLiterals;
         constexpr double timeCnv = 1_ns / Gaudi::Units::ns;
         return timeCnv * athenaT;
     }

◆ timeToAthena()

constexpr double ActsTrk::timeToAthena ( const double actsT )

inlineconstexpr

Converts a time unit from Acts to Athena units.

Parameters

actsT Time interval to convert

Definition at line 56 of file UnitConverters.h.

                                                              {
         using namespace Acts::UnitLiterals;
         constexpr double timeCnv = Gaudi::Units::ns/ 1_ns;
         return timeCnv * actsT;
     }

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

std::underlying_type_t<T> ActsTrk::to_underlying ( T val )

Definition at line 14 of file ActsInspectTruthContentAlg.cxx.

15 { return static_cast< std::underlying_type_t<T> >(val); }

Variable Documentation

◆ DETELEMENT_HASH_MASK

constexpr unsigned int ActsTrk::DETELEMENT_HASH_MASK = ~(1u<<31|1u<<30|1u<<29|1u<<28)

constexpr

Definition at line 21 of file DetectorElementToActsGeometryIdMap.h.

◆ DETELEMENT_TYPE_SHIFT

constexpr unsigned int ActsTrk::DETELEMENT_TYPE_SHIFT = 28

constexpr

Definition at line 20 of file DetectorElementToActsGeometryIdMap.h.

◆ NHitCounter

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

constexpr

Definition at line 19 of file TrackToTruthParticleAssociation.h.

◆ NTruthParticlesPerMeasurement

constexpr unsigned int ActsTrk::NTruthParticlesPerMeasurement = 5

constexpr

Definition at line 14 of file MeasurementToTruthParticleAssociation.h.

◆ NTruthParticlesPerTrack

constexpr unsigned int ActsTrk::NTruthParticlesPerTrack = 5

constexpr

Definition at line 20 of file TrackToTruthParticleAssociation.h.

◆ ONE_TWELFTH

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

constexpr

Definition at line 20 of file StripClusteringTool.cxx.

◆ TrackFindingValidationDebugHists

constexpr bool ActsTrk::TrackFindingValidationDebugHists = false

constexpr

Definition at line 41 of file TrackTruthMatchingBaseAlg.h.

◆ TrackFindingValidationDetailedStat

constexpr bool ActsTrk::TrackFindingValidationDetailedStat = true

constexpr

Definition at line 42 of file TrackTruthMatchingBaseAlg.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

◆ AtlUncalibSourceLinkAccessor

◆ BoundTrackParametersContainer

◆ ConstCovariance

◆ ConstParameters

◆ Covariance

◆ DefaultTrackStateCreator

◆ DetectorElementKey

◆ IndexType

◆ MuonChamberSet

◆ MuonSectorSet

◆ MutablePersistentTrackBackend

◆ MutablePersistentTrackStateBackend

◆ MutableTrackBackend

◆ MutableTrackContainer

◆ MutableTrackStateBackend

◆ Parameters

◆ ParticleVector

◆ PersistentTrackBackend

◆ PersistentTrackContainerBase

◆ PersistentTrackStateBackend

◆ ProtoTrackCollection

◆ rdoListFunc_t

◆ ReturnedHintArr

◆ ReturnedTicketArr

◆ Seed

◆ SeedContainer

◆ staticNodePtr

◆ StIdx

◆ StoredSurface

◆ StripLayerPtr

◆ SurfaceCacheSet

◆ surfacePtr

◆ TicketCounterArr

◆ TrackBackend

◆ TrackContainerBase

◆ TrackStateBackend

◆ TruthParticleHitCounts

◆ volumePtr

Enumeration Type Documentation

◆ DetectorType

◆ NeighbourIndices

Function Documentation

◆ actsLevelVector()

◆ athLevelVector()

◆ convertDirFromActs()

◆ convertDirToActs()

◆ convertMomFromActs()

◆ convertMomToActs()

◆ convertPosFromActs()

◆ convertPosToActs()

◆ createDecoratorKeys()

◆ createDecorators()

◆ decodeSurface() [1/3]

◆ decodeSurface() [2/3]

◆ decodeSurface() [3/3]

◆ encodeSurface() [1/3]

◆ encodeSurface() [2/3]

◆ encodeSurface() [3/3]

◆ energyToActs()

◆ energyToAthena()

◆ getCalibrationContext()

◆ getDepositedEnergy()

◆ getInTruthPropertyName()

◆ getRDOList()

◆ getSimDataDeposits()

◆ getSurfaceGeometryIdOfMeasurement()

◆ getUncalibratedMeasurement()

◆ lengthToActs()

◆ lengthToAthena()

◆ localXFromSourceLink()