ActsTrk Namespace Reference

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
namespace	detail
	Hash functions to pack the source link into unordered_maps / unordered_sets.
namespace	Cache
namespace	ParticleHypothesis
namespace	details
namespace	traits
namespace	ScoreBasedSolverCutsImpl

Classes
class	MuonBlueprintNodeBuilder
	Helper class to build a Blueprint node of the muon system. More...
class	ActsMuonTrackingGeometryTest
	Extrapolation test for the ActsMuonTrackingGeometry for gen3. More...
class	AlignStoreProviderAlg
class	DetectorAlignCondAlg
class	GeometryContextAlg
class	CaloExtensionAlg
	The CaloExtensionAlg takes the ID / ITk tracks from their track state of their last measurement and propagates them to the exit portal of the calorimeter tracking volume. More...
class	TrackContainerReader
class	PixelClusterDataPreparationAlg
class	PixelClusterCacheDataPreparationAlg
class	StripClusterDataPreparationAlg
class	StripClusterCacheDataPreparationAlg
class	HgtdClusterDataPreparationAlg
class	SpacePointDataPreparationAlg
class	SpacePointCacheDataPreparationAlg
struct	CellTmpl
	Definition of a cell to be used by the in-place clusterization. More...
struct	CellContainer
	temporary cell container suitable for the in-place clusterization More...
class	ClusterizationAlg
class	DataPreparationAlg
struct	HgtdAuxDataCache
class	RDOCollectionAdapter< PhaseIIPixelRawDataContainer >
class	RDOAdapter
class	RDOAdapter< PixelRDO_Container >
class	RDOAdapter< PhaseIIPixelRawDataContainer >
class	PixelSpacePointFormationAlgBase
class	RDOCollectionAdapter
class	StripSpacePointFormationAlgBase
	This version of StripSpacePointFormationAlgBase uses xAOD strip clusters to find space points in the ITk strip detectors. More...
class	HgtdClusteringTool
class	HgtdClusterizationAlg
class	HgtdTimedClusteringTool
class	PhaseIIPixelClusterizationAlg
class	PhaseIIPixelCacheClusterizationAlg
class	PixelClusteringToolImpl
class	PixelClusteringTool
class	PhaseIIPixelClusteringTool
class	PixelClusterizationAlg
class	PixelCacheClusterizationAlg
class	PixelSpacePointFormationAlg
	This version of PixelSpacePointFormationAlg uses xAOD pixel clusters to find space points in the ITk pixeldetectors. More...
class	PixelCacheSpacePointFormationAlg
class	PixelSpacePointFormationTool
	Tool to produce pixel space points. More...
struct	StripAuxDataCache
class	StripClusteringTool
class	StripClusterizationAlg
class	StripCacheClusterizationAlg
class	StripInformationHelper
class	StripSpacePointFormationAlg
class	StripCacheSpacePointFormationAlg
class	StripSpacePointFormationTool
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	CaloExtension
	The CaloExtension holds the ID extrapolation states through the calorimeter and the associated CaloClusters. More...
class	ContextUtility
	Utility class to handle the three contexts neeeded in an ACTS reconstruction job 1) GeometryContext -> handles the aligned transforms of the Surfaces & volumes 2) MagneticFieldContext -> Contains the magnetic field 3) CalibrationContext -> Pipes the StoreGate access through the Acts caller chain The utility class declares the data dependencies on the needed conditions by calling the declareProperty on its client. More...
class	MeasurementToTruthParticleAssociation
class	MutableMultiTrajectory
	Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends. 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...
struct	DataLinkHolder
class	PersistentTrackContainer
struct	MutablePersistentTrackContainer
class	PrepRawDataAssociation
struct	ProtoTrack
struct	SpacePointRange
struct	Seed
struct	SeedContainer
class	TrackContainer
class	IndexingPolicy
class	MutableTrackContainerHandlesHelper
class	ConstTrackContainerHandlesHelper
struct	TrackContainerUtils
	Convenience struct which defines track augmentations. More...
class	TrackSummaryContainer
class	MutableTrackSummaryContainer
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	TrackToTruthParticleAssociation
class	ActsToTrkConverterTool
class	ActsToTrkConvertorAlg
class	ActsToTrkFitterWrapTool
	Tool wrapping an ACTS track fitter tool to expose the Trk::ITrackFitter interface. More...
class	ActsToXAODTrackConverterAlg
	Conversion algorithm to transform the Acts track container into an xAOD track container which can be persitified in an ESD. More...
class	GeometryRealmConvTool
	Implementation of the IGeometryRealmConvTool. More...
class	SeedToTrackCnvAlg
class	TrackToTrackParticleCnvAlg
	Conversion algorithm to translate multiple transient Acts track containers to an xAOD track particle container. More...
class	TrackToTrackParticleCnvTool
class	TrkToActsConvertorAlg
	Algorithm convert Trk::Track to ACTS multistate objects. More...
class	xAODtoTrkConverterAlg
	Algorithm that converts the Acts::Tracks from which the xAOD::TrackParticle is made into a Trk::Track object and fills the trackLink of the xAOD::TrackParticle. More...
class	ActsVolumeIdToDetectorElementCollectionMap
struct	DetectorElementToActsGeometryIdMap
class	ActsVolumeIdToDetectorElementCollectionMappingAlg
class	BeamPipeBlueprintNodeBuilder
	Helper class to build the BeamPipe Blueprint node It adds the beam pipe as a node to the Blueprint. More...
class	CaloBlueprintNodeBuilder
	Builds the Calo Blueprint Node. More...
class	ExtrapolationTool
class	HgtdBlueprintNodeBuilder
	Helper class to build the HgtdBlueprint node It adds the system as a node to the Blueprint. More...
class	ItkBlueprintNodeBuilder
	Helper class to build the ItkBlueprint node It adds the system as a node to the Blueprint. More...
class	ITkMaterialDecoratorTool
	Mutable tracking geometry visitor to load the material on the tracking surfaces inside the ITk. More...
class	TrackingGeoAlignVisitor
	TrackingGeometryVisitor to load the aligned surface and volume transforms into the DetectorAlignStore of a given subdetector. More...
class	TrackingGeometrySvc
class	WriteTrackingGeometry
	Algorithm that uses the Acts JSON plugin to dump the tracking geometry into a JSON format which can be read back by Acts Standalone. More...
class	DetectorAlignStore
class	GeometryContext
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
	ATLAS interface of a detector element. More...
class	IExtrapolationTool
	Tool to extrapolate bound track parameters through the Acts::TrackingGeometry. More...
class	IGeometryRealmConvTool
	Interface for the conversion tool to translate the surface and track parameter objects between the Acts & the ATLAS Trk realm. More...
class	IRefineTrackingGeoTool
	Interface to pass mutable TrackingGeometry visitors to the built tracking geometry before the geometry is becoming a const object. More...
class	ISurfacePlacement
	Extension of the interface of the Acts::SurfacePlacementBase for ATLAS. More...
class	ITrackingGeometrySvc
	Interface class for the ATLAS service providing the ActsTrackingGeometry. More...
class	IVolumePlacement
	ATLAS extension of the VolumePlacementBase interface. More...
class	SurfacePlacement
	: Helper class to assign a @Acts::SurfacePlacementBase to the Acts::Surfaces in order to make them alignable. More...
class	AlignableGeoPositioning
class	IReadoutSurfacePositioning
	Interface extension for caches used to hold the transforms of surfaces from the readout geometry. More...
class	ReadoutSurfacePositioning
	Extension to handle the caching process of the transform held by the cache. More...
class	VolumePlacement
	Implementation to make a (tracking) volume alignable. More...
class	CUDAClusterizationAlgProviderTool
	Tool providing CUDA-based traccc clusterization and measurement sorting algorithms. More...
class	CUDASPFormationAlgProviderTool
	Tool providing CUDA-based traccc spacepoint formation algorithm. More...
class	DeviceClusterizationAlg
	Algorithm executing traccc clusterization and measurement sorting on the GPU. More...
class	DeviceSPFormationAlg
	Algorithm executing traccc (pixel) spacepoint formation on the GPU. More...
class	IDeviceClusterizationAlgProviderTool
class	IDeviceSPFormationAlgProviderTool
class	PhaseIIRDOtoTracccCellConverterAlg
	Converts Pixel and Strip PhaseII RDO container into Traccc cells, the input to the Acts GPU reconstruction chain. More...
class	RDOtoTracccCellConverterAlg
	Converts Pixel and Strip RDO container into Traccc cells, the input to the Acts GPU reconstruction chain. More...
struct	RDOtoTracccCellConverterCommons
	This struct contains the components common to RDOtoTracccCellConverterAlg and PhaseIIRDOtoTracccCellConverterAlg. More...
class	TracccCellValidationAlg
	Algo that compares two traccc silicon_cell_collection. More...
class	TracccMeasurementConverterAlg
	Algorithm converting traccc measurements (device buffer) to xAOD clusters (host container). More...
class	JSONDeviceDetectorDescriptionProviderSvc
	Service providing device detector description from JSON files. More...
class	IDeviceDetectorDescriptionProviderSvc
class	IMaterialWriterTool
	Interface definition for material writing. More...
class	MaterialMapping
	Reads the MaterialTracks and produces the material maps for the Tracking Geometry. More...
class	MaterialTrackReader
	Writes out RecordedMaterialTrackCollection to a root file. More...
class	MaterialTrackRecorder
	Collects the G4 steps and writes out RecordedMaterialTrackCollection to a store gate. More...
class	MaterialTrackRecorderTool
class	MaterialTrackWriter
	Writes out RecordedMaterialTrackCollection to a root file. More...
class	MaterialValidation
	Reads the MaterialTracks and produces the material maps for the Tracking Geometry. More...
class	RootMaterialWriterTool
	Material decorator from Root format. More...
class	ActsClusterComparisonAlg
class	ActsInspectTruthContentAlg
class	EstimatedTrackParamsAnalysisAlg
class	ExtrapolationTestAlg
class	HgtdClusterAnalysisAlg
class	HgtdClusterValidationPlots
class	ITkAlignMonResidualsAlg
class	PhysValTool
class	PixelClusterAnalysisAlg
class	PixelClusterValidationPlots
class	PixelSpacePointValidationPlots
class	ReadoutGeoDumpAlg
	Algorithm that scans the tracking geometry and dumps the transforms and surface bounds of the individual readout elements into a tree It's used in the context of the validtion of the SQLite workflow applied on data. More...
class	SeedAnalysisAlg
class	SeedsToTrackParamsAlg
class	SeedToTrackAnalysisAlg
class	SpacePointAnalysisAlg
class	StripClusterAnalysisAlg
class	StripClusterValidationPlots
class	StripSpacePointValidationPlots
class	TrackAnalysisAlg
class	TrackParticleAnalysisAlg
class	ActsTrackStateOnSurfaceDecoratorAlg
class	GNNScoreDecoratorAlg
class	MeasurementToTrackParticleDecorationAlg
class	PixelClusterSiHitDecoratorAlg
class	PixelClusterTruthDecoratorAlg
class	StripClusterSiHitDecoratorAlg
class	StripClusterTruthDecoratorAlg
class	GbtsSeedingTool
class	GenericSeedingAlg
class	GridTripletSeedingTool
class	TrackParamsEstimationTool
class	PrdAssociationAlg
class	CaloBasedRoICreatorTool
class	FullScanRoICreatorTool
class	RegionsOfInterestCreatorAlg
class	TestRoICreatorTool
struct	RDOContainerTraits
class	ICellClusteringToolBase
class	IFitterTool
	Generic interface class to fit xAOD::Uncalibrated measurements to (multi)-trajectories. More...
class	IHGTDClusteringTool
class	IHGTDOnBoundStateCalibratorTool
class	IHGTDOnTrackCalibratorTool
class	ClusterCalibratorBase
class	OnBoundStateCalibratorBase
	Base class of a InDet calibrator object. More...
class	IOnBoundStateCalibratorTool
	interface of a tool to create a calibrator for a certain cluster type. More...
class	OnTrackCalibratorBase
class	IOnTrackCalibratorTool
struct	RDOContainerTraits< PhaseIIPixelRawDataContainer >
class	IPhaseIIPixelClusteringTool
struct	RDOContainerTraits< PixelRDO_Container >
class	IPixelClusteringTool
class	IPixelOnBoundStateCalibratorTool
class	IPixelOnTrackCalibratorTool
class	IPixelSpacePointFormationTool
	Base class for pixel space point formation tool. More...
class	IProtoTrackCreatorTool
class	IRoICreatorTool
class	ISeedingTool
class	IStripClusteringTool
class	IStripOnBoundStateCalibratorTool
class	IStripOnTrackCalibratorTool
struct	StripSP
class	IStripSpacePointFormationTool
class	ITrackConverterTool
	ConversionTool between the Acts Track EDM and the Trk::Track EDM. More...
class	ITrackParamsEstimationTool
class	ITrackToTrackParticleCnvTool
	Interface for a tool that converts a single Acts track proxy into an xAOD::TrackParticle. More...
class	AmbiguityResolutionAlg
struct	MeasurementParameterMap
struct	MeasurementCalibrator
class	NNinput
struct	NumberNNoutput
class	PositionNNoutput
class	GaussianSumFitterTool
class	GlobalChiSquareFitterTool
class	HGTDTrackExtensionAlg
class	HGTDTruthTrackDecorationAlg
class	IMeasurementSelector
class	ITkAnalogueClusteringTool
class	ITkNNClusterCalibratorTool
class	ITkStripCalibrationTool
class	KalmanFitterTool
class	ProtoTrackCreationAndFitAlg
class	ProtoTrackReportingAlg
	Very lightweight algorithm to print out the results of the EF track finding. More...
class	RandomProtoTrackCreatorTool
class	ReFitterAlg
class	ScoreBasedAmbiguityResolutionAlg
class	TrackExtensionAlg
class	TrackFindingAlg
class	TrackFindingBaseAlg
class	TrackFindingGNNAlg
class	TrackStatePrinterTool
class	TruthGuidedProtoTrackCreatorTool
class	PixelClusterToTruthAssociationAlg
class	StripClusterToTruthAssociationAlg
class	HgtdClusterToTruthAssociationAlg
class	DummyRDOList
struct	has_rdoList
struct	has_rdoList< Object, std::void_t< rdoListFunc_t< Object > > >
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	TrackFindingValidationAlg
class	TrackParticleTruthDecorationAlg
class	TrackToTruthAssociationAlg
class	TrackTruthMatchingBaseAlg
class	TruthParticleHitCountAlg
class	HoughVtxFinderTool
class	AdaptiveMultiPriVtxFinderTool
class	IterativePriVtxFinderTool

Typedefs
using	CaloExtensionContainer = DataVector<CaloExtension>
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
typedef std::vector< ActsTrk::ProtoTrack >	ProtoTrackCollection
using	TrackBackend = Acts::ConstVectorTrackContainer
using	MutableTrackBackend = Acts::VectorTrackContainer
using	TrackStateBackend = Acts::ConstVectorMultiTrajectory
using	MutableTrackStateBackend = Acts::VectorMultiTrajectory
using	TrackContainerBase
using	MutableTrackContainer
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	DetectorElementKey = unsigned int
using	RecordedMaterialTrackCollection = std::vector<Acts::RecordedMaterialTrack>
using	GeoContextReadKey_t = SG::ReadHandleKey<GeometryContext>
	Abrivate the ReadHandleKey to declare the data dependency on the Geometry context.
using	HGTDOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::HGTDCluster,3>
template<typename traj_t>
using	HGTDOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::HGTDCluster,3, traj_t>
using	PixelOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::PixelCluster,2>
template<typename traj_t>
using	PixelOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::PixelCluster,2, traj_t>
using	StripOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::StripCluster,1>
template<typename traj_t>
using	StripOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::StripCluster,1, traj_t>
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 class	caloRegion {   DiscNegativeZ , DiscPositiveZ , CylinderSymmetricZZero , CylinderNegativeZ ,   CylinderPositiveZ }
enum class	DetectorType : std::uint8_t {   Pixel , Sct , Trt , Hgtd ,   Mdt , Rpc , Tgc , Csc ,   Mm , sTgc , UnDefined }
	Simple enum to Identify the Type of the ACTS sub detector. More...
enum class	SystemEnvelope : std::uint8_t { ITkExit , CaloExit , MsExit }
	Define an enumeration to retrieve the envelope tracking volume from. More...
enum class	ClusterTruthOrigin { UNIDENTIFIED = 0 , TRUTH_PARTICLE = 1 , UNRELATED_PARTICLE = 2 , SECONDARY = 3 }

Functions
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.
static std::pair< Eigen::Matrix< float, 1, 1 >, Eigen::Matrix< float, 3, 1 > >	computePosition (const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > &cluster, const InDetDD::SiDetectorElement &element, const InDetDD::SiDetectorDesign &design, double lorentzShift, bool isITk)
static InDetDD::SiLocalPosition	computeCentrePosition (const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > &cluster, const InDetDD::SiDetectorDesign &design)
static float	computeRotatedLocalCov (const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > &cluster, float localPos, float localCov, const InDetDD::SiDetectorElement &element, const InDetDD::SiDetectorDesign &design)
const CaloExtension *	getCaloExtension (const xAOD::TrackParticle &track)
	Retrieve a pointer to the CaloExtension linked with the passed TrackParticle.
std::optional< ActsTrk::TrackContainer::ConstTrackProxy >	getActsTrack (const xAOD::TrackParticle &trkPart)
	Return the proxy to the Acts track from which the track particle was made frome.
std::optional< ActsTrk::TrackContainer::ConstTrackStateProxy >	lastMeasurementState (const xAOD::TrackParticle &trkPart, const bool skipOutlier=true)
	Returns the track state proxy corresponding to the last measurement on track.
std::optional< ActsTrk::TrackContainer::ConstTrackStateProxy >	firstMeasurementState (const xAOD::TrackParticle &trkPart, const bool skipOutlier=true)
	Returns the track state proxy corresponding to the measurement that is closest to the defining track parameter.
std::optional< Acts::BoundTrackParameters >	lastTrackParameters (const xAOD::TrackParticle &trkPart, const bool skipOutlier=true)
	Returns the last MeasurementState in form of Acts::BoundTrackParameters.
std::optional< Acts::BoundTrackParameters >	firstTrackParameters (const xAOD::TrackParticle &trkPart, const bool skipOutlier=true)
	Returns the first MeasurementState in form of Acts::BoundTrackParameters.
DetectorType	toDetType (const xAOD::UncalibMeasType mType)
	Converts the uncalibrated measurement type to a detector type.
xAOD::UncalibMeasType	toMeasType (const DetectorType dType)
	Conversts the detector type to an uncalibrated measurement type.
Trk::TrackInfo::TrackFitter	toTrkFitterType (const xAOD::TrackFitter fType)
	Converts xAOD fitter type to Trk fitter type.
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
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.
std::unique_ptr< Trk::TrackParameters >	rotateParams (const Trk::TrackParameters &inPars, const Trk::Surface &target)
DetectorElementKey	makeDetectorElementKey (xAOD::UncalibMeasType meas_type, unsigned int identifier_hash)
Acts::GeometryIdentifier	getSurfaceGeometryIdOfMeasurement (const DetectorElementToActsGeometryIdMap &detector_element_to_geoid, const xAOD::UncalibratedMeasurement &measurement)
std::ostream &	operator<< (std::ostream &ostr, const DetectorType type)
	Pipe the detector type to an outstream object.
std::ostream &	operator<< (std::ostream &ostr, const SystemEnvelope type)
	Pipe the Volume envelope to an oustream object.
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.
void	encodeSurface (xAOD::TrackSurface *backend, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)
	As above, but works on xAOD::TrackSurface object.
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.
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.
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)
void	sort_traccc_soa (traccc::edm::silicon_cell_collection::device &sorted_cells, traccc::edm::silicon_cell_collection::device const &cells)
std::pair< int, int >	countPixelStrip (const traccc::edm::measurement_collection::const_device &measurements)
	Count the number of measurements 2D (pixel) vs 1D (strip).
template<typename ClusterT, typename AuxContainerT, typename ContainerT = DataVector<ClusterT>>
std::pair< std::unique_ptr< ContainerT >, std::unique_ptr< AuxContainerT > >	makeOutputContainer (const EventContext &ctx, int n)
template<typename MEAS>
void	fillStripCluster (const MEAS &meas, const Identifier &athenaId, const SCT_ID *stripID, const InDetDD::SCT_DetectorManager *stripManager, xAOD::StripCluster &xaod_scl, std::size_t combinedIndex)
template<typename MEAS>
void	fillPixelCluster (const MEAS &meas, const Identifier &athenaId, const PixelID *pixelID, const InDetDD::PixelDetectorManager *pixelManager, xAOD::PixelCluster &xaod_pcl, std::size_t combinedIndex)
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.
constexpr double	energyToAthena (const double actsE)
	Converts an energy scalar from Acts to Athena units.
constexpr double	lengthToActs (const double athenaL)
	Converts a length scalar from Acts to Athena units.
constexpr double	lengthToAthena (const double actsL)
	Converts a length scalar from Acts to Athena units.
template<std::floating_point T>
constexpr auto	timeToActs (T athenaT)
	Converts a time unit from Athena to Acts units.
template<std::floating_point T>
constexpr double	timeToAthena (T actsT)
	Converts a time unit from Acts to Athena units.
template<std::floating_point T>
constexpr auto	timeCovToActs (T athenaTCov)
	Converts a time covariance element from Athena to Acts units.
template<std::floating_point T>
constexpr double	timeCovToAthena (T actsTCov)
	Converts a time covariance element from Acts to Athena units.
constexpr double	velocityToActs (const double athenaV)
	Converts a velocity from Athena to Acts units.
constexpr double	accelerationToActs (const double athenaA)
	Converts an acceleration from Athena to Acts units.
Acts::Vector3	convertDirToActs (const Amg::Vector3D &athenaDir)
	Converts a direction vector from athena units into acts units.
Amg::Vector3D	convertDirFromActs (const Acts::Vector3 &actsDir)
	Converts a direction vector from acts units into athena units.
Acts::Vector4	convertPosToActs (const Amg::Vector3D &athenaPos, const double athenaTime=0.)
	Converts a position vector & time from Athena units into Acts units.
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.
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.
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.
void	matchPixelClusters (std::vector< const xAOD::PixelCluster * > &monitored_list, std::vector< const xAOD::PixelCluster * > &reference_list, const std::string &module_id, std::vector< std::pair< const xAOD::PixelCluster *, const xAOD::PixelCluster * > > &pairs)
void	matchStripClusters (std::vector< const xAOD::StripCluster * > &monitored_list, std::vector< const xAOD::StripCluster * > &reference_list, const std::string &module_id, std::vector< std::pair< const xAOD::StripCluster *, const xAOD::StripCluster * > > &pairs)
static std::string	atlasSurfaceName (const Acts::Surface *measurement_surface)
static void	printHeader (int type, bool extra=false)
static void	printVec3 (const Acts::Vector3 &p)
static void	printVec3 (const Acts::Vector3 &p, const Acts::Vector3 &cmp, int precision=3)
static void	printVec2 (const Acts::Vector2 &p, const char *estimated=nullptr)
static void	printVec2 (const Acts::Vector2 &p, const Acts::Vector2 &cmp, const char *estimated=nullptr, int precision=4)
static void	printMeasurement (const Acts::GeometryContext &tgContext, const Acts::Surface *surface, const std::tuple< Acts::Vector2, Amg::Vector2D, int, int > &locData, bool compareMeasurementTransforms=false)
static std::tuple< Acts::Vector2, Amg::Vector2D, int, int >	localPositionStrip2D (const Acts::GeometryContext &tgContext, const xAOD::UncalibratedMeasurement &measurement, const Acts::Surface *surface, const xAOD::SpacePoint *sp)
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 float	oneStripSF = 1.1025
constexpr float	twoStripSF = 0.0729
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.

Includes the GeoPrimitives.

Ensure that the ATLAS eigen extension is included first.

Include the GeoPrimitives which need to be put first.

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

The DetectorAlignStore is a cache class to hold the aligned surface local->global transforms and the both volume transforms that are associated with an ATLAS sub detector technology. The cache is written such that it can be lazily populated or fully populated at its creation.

The cache is structured in three components: 1) geoModelAlignment: This store contains all information to apply rigid alignment corrections to the ReadoutElement. All readout elements are assoicated with a GeoVPhysVol objects which are positioned in space via a series of GeoTransforms and GeoAlignableTransforms. The latter represent the alignment fix points from which the alignment corrections are applied. GeoModel then aligns all subvolumes according to the deltas 2) trackingAlignment: GeoModel usally does not keep the fully assembled transforms in memory. The actual caching of them is taken over by the trackingAlignment Clients which want to push a transform onto the cache need to draw a unique ticket from the store at construction. This ticket is valid for a given sub detector and can be used to query the cache whether a transform has been already pushed or to ask for the transform itself 3) internalAlignment: Is an empty sub class which is meant to store conditions data to correct the readout geometry for surface deformations (E.g. muon b-lines, as-built)

If the package is loaded in AthSimulation, the Acts library is not avaialble

ActsGeometry context carries all information related to the aboslute positions of the Readout geometry Per detector technology (e.g. Mdt), it contains an ActsTrk::DetectorAlignmentStore which carries pointers to the rigid alignment transfomrations of each FullPhysical volume representing the detector sensor envelope. Further, it carries the transformations for each tracking layer

In AthSimulation, the Acts core library is not available yet

Typedef Documentation

AtlUncalibSourceLinkAccessor

using ActsTrk::AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor

Definition at line 64 of file HGTDTrackExtensionAlg.h.

BoundTrackParametersContainer

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

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

CaloExtensionContainer

using ActsTrk::CaloExtensionContainer = DataVector<CaloExtension>

Definition at line 72 of file Acts/ActsEvent/ActsEvent/CaloExtension.h.

ConstCovariance

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

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

ConstParameters

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

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

Covariance

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

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

DefaultTrackStateCreator

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

Definition at line 65 of file HGTDTrackExtensionAlg.h.

DetectorElementKey

using ActsTrk::DetectorElementKey = unsigned int

Definition at line 12 of file DetectorElementToActsGeometryIdMap.h.

GeoContextReadKey_t

using ActsTrk::GeoContextReadKey_t = SG::ReadHandleKey<GeometryContext>

Abrivate the ReadHandleKey to declare the data dependency on the Geometry context.

Definition at line 64 of file GeometryContext.h.

HGTDOnBoundStateCalibratorBase

using ActsTrk::HGTDOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::HGTDCluster,3>

Definition at line 11 of file IHGTDOnBoundStateCalibratorTool.h.

HGTDOnTrackCalibratorBase

template<typename traj_t>

using ActsTrk::HGTDOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::HGTDCluster,3, traj_t>

Definition at line 13 of file IHGTDOnTrackCalibratorTool.h.

IndexType

using ActsTrk::IndexType = std::uint32_t

Definition at line 18 of file Decoration.h.

MutablePersistentTrackBackend

using ActsTrk::MutablePersistentTrackBackend = ActsTrk::MutableTrackSummaryContainer

Definition at line 14 of file PersistentTrackContainer.h.

MutablePersistentTrackStateBackend

using ActsTrk::MutablePersistentTrackStateBackend = ActsTrk::MutableMultiTrajectory

Definition at line 16 of file PersistentTrackContainer.h.

MutableTrackBackend

using ActsTrk::MutableTrackBackend = Acts::VectorTrackContainer

Definition at line 16 of file TrackContainer.h.

MutableTrackContainer

using ActsTrk::MutableTrackContainer

Initial value:

Acts::TrackContainer<MutableTrackBackend,
                                                    MutableTrackStateBackend,
                                                    Acts::detail::ValueHolder>

Definition at line 25 of file TrackContainer.h.

MutableTrackStateBackend

using ActsTrk::MutableTrackStateBackend = Acts::VectorMultiTrajectory

Definition at line 18 of file TrackContainer.h.

Parameters

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

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

ParticleVector

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

Definition at line 17 of file MeasurementToTruthParticleAssociation.h.

PersistentTrackBackend

using ActsTrk::PersistentTrackBackend = ActsTrk::TrackSummaryContainer

Definition at line 15 of file PersistentTrackContainer.h.

PersistentTrackContainerBase

using ActsTrk::PersistentTrackContainerBase

Initial value:

Acts::TrackContainer<ActsTrk::PersistentTrackBackend,
                                                           ActsTrk::PersistentTrackStateBackend,
                                                           ActsTrk::DataLinkHolder>

Definition at line 33 of file PersistentTrackContainer.h.

PersistentTrackStateBackend

using ActsTrk::PersistentTrackStateBackend = ActsTrk::MultiTrajectory

Definition at line 17 of file PersistentTrackContainer.h.

PixelOnBoundStateCalibratorBase

using ActsTrk::PixelOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::PixelCluster,2>

Definition at line 11 of file IPixelOnBoundStateCalibratorTool.h.

PixelOnTrackCalibratorBase

template<typename traj_t>

using ActsTrk::PixelOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::PixelCluster,2, traj_t>

Definition at line 13 of file IPixelOnTrackCalibratorTool.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 = decltype(std::declval<Object>().rdoList())

Definition at line 94 of file MeasurementToTruthAssociationAlg.h.

RecordedMaterialTrackCollection

using ActsTrk::RecordedMaterialTrackCollection = std::vector<Acts::RecordedMaterialTrack>

Definition at line 14 of file RecordedMaterialTrackCollection.h.

StoredSurface

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

Definition at line 65 of file MultiTrajectory.h.

StripOnBoundStateCalibratorBase

using ActsTrk::StripOnBoundStateCalibratorBase = OnBoundStateCalibratorBase<xAOD::StripCluster,1>

Definition at line 11 of file IStripOnBoundStateCalibratorTool.h.

StripOnTrackCalibratorBase

template<typename traj_t>

using ActsTrk::StripOnTrackCalibratorBase = OnTrackCalibratorBase<xAOD::StripCluster,1, traj_t>

Definition at line 13 of file IStripOnTrackCalibratorTool.h.

TrackBackend

using ActsTrk::TrackBackend = Acts::ConstVectorTrackContainer

Definition at line 15 of file TrackContainer.h.

TrackContainerBase

using ActsTrk::TrackContainerBase

Initial value:

Acts::TrackContainer<TrackBackend,
                                                 TrackStateBackend,
                                                 Acts::detail::ValueHolder>

Definition at line 21 of file TrackContainer.h.

TrackStateBackend

using ActsTrk::TrackStateBackend = Acts::ConstVectorMultiTrajectory

Definition at line 17 of file TrackContainer.h.

TruthParticleHitCounts

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

Definition at line 19 of file TruthParticleHitCounts.h.

Enumeration Type Documentation

caloRegion

enum class ActsTrk::caloRegion

strong

Enumerator
DiscNegativeZ
DiscPositiveZ
CylinderSymmetricZZero
CylinderNegativeZ
CylinderPositiveZ

Definition at line 28 of file CaloBlueprintNodeBuilder.h.

{DiscNegativeZ, DiscPositiveZ, CylinderSymmetricZZero, CylinderNegativeZ, CylinderPositiveZ};

ClusterTruthOrigin

enum class ActsTrk::ClusterTruthOrigin

strong

Enumerator
UNIDENTIFIED
TRUTH_PARTICLE
UNRELATED_PARTICLE
SECONDARY

Definition at line 35 of file HGTDTruthTrackDecorationAlg.h.

                                {
    UNIDENTIFIED = 0,       // ITk track is not associated with a truth particle, so not identified
    TRUTH_PARTICLE = 1,     // originates from the tested truth particle
    UNRELATED_PARTICLE = 2, // originates from a particle that is unrelated to the ITk track
    SECONDARY = 3           // originates from some secondary interaction
  };

DetectorType

enum class ActsTrk::DetectorType : std::uint8_t

strong

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

Enumerator
Pixel	Inner detector legacy.
Sct
Trt
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 25 of file GeometryDefs.h.

                           : std::uint8_t {
        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.

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

SystemEnvelope

enum class ActsTrk::SystemEnvelope : std::uint8_t

strong

Define an enumeration to retrieve the envelope tracking volume from.

Enumerator
ITkExit
CaloExit
MsExit

Definition at line 42 of file GeometryDefs.h.

                             : std::uint8_t {
        ITkExit,  // Envelope volume of the ITk
        CaloExit, // Enevelope volume of the Calorimeter / Ms entrance
        MsExit // Envelope around the Muon system
    };

Function Documentation

accelerationToActs()

double ActsTrk::accelerationToActs ( const double athenaA )

inlineconstexpr

Converts an acceleration from Athena to Acts units.

Parameters

athenaA

Acceleration to convert

Definition at line 90 of file UnitConverters.h.

                                                                     {
        return athenaA / Acts::square(timeToActs(1.));
    }

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

atlasSurfaceName()

std::string ActsTrk::atlasSurfaceName ( const Acts::Surface * measurement_surface )

static

Definition at line 92 of file TrackStatePrinterTool.cxx.

  {
     if (measurement_surface) {
        const auto* acts_detector_element = getActsDetectorElement(measurement_surface);
        if (acts_detector_element) {
           const InDetDD::SiDetectorElement *detElem = dynamic_cast< const InDetDD::SiDetectorElement *>(acts_detector_element->upstreamDetectorElement());
           if (detElem) {
              if (auto idHelper = detElem->getIdHelper())
                 {
                    auto name = idHelper->show_to_string(detElem->identify());
                    if (name.size() >= 2 && name[0] == '[' && name[name.size() - 1] == ']')
                       {
                          return name.substr(1, name.size() - 2);
                       }
                    else
                       {
                          return name;
                       }
                 }
           }
        }
     }
    return {};
  }

computeCentrePosition()

InDetDD::SiLocalPosition ActsTrk::computeCentrePosition ( const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > & cluster, const InDetDD::SiDetectorDesign & design )

static

Definition at line 254 of file StripClusteringTool.cxx.

{   // For Inner Detector SCT, compute the local position of the cluster center using the strip positions.
    InDetDD::SiCellId frontId = cluster.front().coordinates()[0];
    InDetDD::SiLocalPosition pos = design.localPositionOfCell(frontId);
    if (cluster.size() > 1) {
      InDetDD::SiCellId backId = cluster.back().coordinates()[0];
      InDetDD::SiLocalPosition backPos = design.localPositionOfCell(backId);
      pos = 0.5 * (pos + backPos);
    }
    return pos;
}

computePosition()

std::pair< Eigen::Matrix< float, 1, 1 >, Eigen::Matrix< float, 3, 1 > > ActsTrk::computePosition ( const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > & cluster, const InDetDD::SiDetectorElement & element, const InDetDD::SiDetectorDesign & design, double lorentzShift, bool isITk )

static

Definition at line 218 of file StripClusteringTool.cxx.

{
 
 
    InDetDD::SiCellId frontId = cluster.front().coordinates()[0];
    InDetDD::SiLocalPosition pos = design.localPositionOfCell(frontId);
    if (cluster.size()>1) {
      InDetDD::SiCellId backId = cluster.back().coordinates()[0];
      InDetDD::SiLocalPosition backPos =
         design.localPositionOfCell(backId);
    pos = 0.5 * (pos + backPos);
    }
 
    // update the xPhi position
    pos.xPhi( pos.xPhi() + lorentzShift );
    // @TODO use local to global of Acts surface instead
    Eigen::Matrix<float,3,1> posG(element.surface().localToGlobal(pos).cast<float>());
    
    if ((not element.isBarrel()) and isITk) {
        assert(dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&design) != nullptr);
    const InDetDD::StripStereoAnnulusDesign& annulusDesign =
        static_cast<const InDetDD::StripStereoAnnulusDesign&>
        (design);
    pos = annulusDesign.localPositionOfCellPC(element.cellIdOfPosition(pos));
    }
 
    return std::make_pair(Eigen::Matrix<float,1,1>(pos.xPhi()),
              std::move(posG));
}

computeRotatedLocalCov()

float ActsTrk::computeRotatedLocalCov ( const InPlaceClusterization::ClusterProxy< const IStripClusteringTool::CellContainer > & cluster, float localPos, float localCov, const InDetDD::SiDetectorElement & element, const InDetDD::SiDetectorDesign & design )

static

Definition at line 268 of file StripClusteringTool.cxx.

{   // For Inner Detector SCT, in the case of endcap modules, rotate the local covariance to account for the stereo angle.
    const bool rotate = (design.shape() == InDetDD::Trapezoid || design.shape() == InDetDD::Annulus);
    if (!rotate) {
      return localCov;
    }
 
    const auto* sctDesign = dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&design);
    if (sctDesign == nullptr) {
      return localCov;
    }
 
    const InDetDD::SiLocalPosition centrePos = computeCentrePosition(cluster, design);
    const auto ends = sctDesign->endsOfStrip(centrePos);
    const double stripL = std::abs(ends.first.xEta() - ends.second.xEta());
    const double iphipitch = 1. / element.phiPitch();
    const Amg::Vector2D localPos2D{localPos, 0.0};
    const double w = element.phiPitch(localPos2D) * iphipitch;
 
    const double sn = element.sinStereoLocal(localPos2D);
    const double sn2 = sn * sn;
    const double cs2 = 1. - sn2;
    const double v0 = localCov * w * w;
    const double v1 = stripL * stripL * ONE_TWELFTH;
 
    const float rotatedCov = cs2 * v0 + sn2 * v1;
    // copied from InDet::SCT_ClusteringTool, but in ACTS-based tracking, SCT cov is 1-dimensional, just keep the rotatedCov(0,0) for the moment
    // rotatedCov(0,1) = rotatedCov = sn * sqrt(cs2) * (v0 - v1);
    // rotatedCov(1,1) = sn2 * v0 + cs2 * v1;
    return rotatedCov;
}

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 100 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 95 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 141 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 129 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 118 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 106 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;
    }

countPixelStrip()

std::pair< int, int > ActsTrk::countPixelStrip

(

const traccc::edm::measurement_collection::const_device &

measurements

)

Count the number of measurements 2D (pixel) vs 1D (strip).

Definition at line 45 of file TracccMeasurementConverterAlg.cxx.

                                                                   {
  int n_pixels = 0;
  int n_strips = 0;
  for (std::size_t i = 0; i < measurements.size(); ++i) {
    if (measurements.at(i).dimensions() == 2u) {
      ++n_pixels;
    } else {
      ++n_strips;
    }
  }
  return {n_pixels, n_strips};
}

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 92 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 137 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 142 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 Point:
      case Other:
        surfaceType = xAOD::SurfaceType::Other;
        break;
  }
 
  Acts::RotationMatrix3 lRotation =
      surface->localToGlobalTransform(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 80 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 73 of file SurfaceEncoding.cxx.

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

energyToActs()

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 23 of file UnitConverters.h.

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

energyToAthena()

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 30 of file UnitConverters.h.

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

fillPixelCluster()

template<typename MEAS>

void ActsTrk::fillPixelCluster	(	const MEAS &	meas,
		const Identifier &	athenaId,
		const PixelID *	pixelID,
		const InDetDD::PixelDetectorManager *	pixelManager,
		xAOD::PixelCluster &	xaod_pcl,
		std::size_t	combinedIndex )

Definition at line 109 of file TracccMeasurementConverterAlg.cxx.

                                               {
  const IdentifierHash pixHash = pixelID->wafer_hash(athenaId);
  const InDetDD::SiDetectorElement* pDE =
      pixelManager->getDetectorElement(pixHash);
 
  const Amg::Vector2D localPos(meas.local_position()[0],
                               meas.local_position()[1]);
  const Amg::Vector3D gp = pDE->globalPosition(localPos);
 
  Eigen::Matrix<float, 2, 1> localPosition(localPos.x(), localPos.y());
  Eigen::Matrix<float, 2, 2> localCovariance =
      Eigen::Matrix<float, 2, 2>::Zero();
  localCovariance(0, 0) = meas.local_variance()[0];
  localCovariance(1, 1) = meas.local_variance()[1];
 
  const Identifier hitId(athenaId.get_compact() + combinedIndex);
 
  xaod_pcl.setIdentifierHash(pixHash);
  xaod_pcl.setMeasurement<2>(pixHash, localPosition, localCovariance);
  xaod_pcl.globalPosition() = Eigen::Matrix<float, 3, 1>(gp.x(), gp.y(), gp.z());
  xaod_pcl.setIdentifier(hitId.get_compact());
  xaod_pcl.setWidthInEta(meas.diameter());
}

fillStripCluster()

template<typename MEAS>

void ActsTrk::fillStripCluster	(	const MEAS &	meas,
		const Identifier &	athenaId,
		const SCT_ID *	stripID,
		const InDetDD::SCT_DetectorManager *	stripManager,
		xAOD::StripCluster &	xaod_scl,
		std::size_t	combinedIndex )

Definition at line 80 of file TracccMeasurementConverterAlg.cxx.

                                               {
  const IdentifierHash stripHash = stripID->wafer_hash(athenaId);
  const InDetDD::SiDetectorElement* pDE =
      stripManager->getDetectorElement(stripHash);
 
  Eigen::Matrix<float, 1, 1> localPosition = Eigen::Matrix<float, 1, 1>::Zero();
  Eigen::Matrix<float, 1, 1> localCovariance =
      Eigen::Matrix<float, 1, 1>::Zero();
 
  if (pDE->isBarrel()) {
    localPosition(0, 0) = meas.local_position()[0];
    localCovariance(0, 0) = meas.local_variance()[0];
  } else {
    localPosition(0, 0) = meas.local_position()[1];
    localCovariance(0, 0) = meas.local_variance()[1];
  }
 
  const Identifier hitId(athenaId.get_compact() + combinedIndex);
 
  xaod_scl.setMeasurement<1>(stripHash, localPosition, localCovariance);
  xaod_scl.setIdentifierHash(stripHash);
  xaod_scl.setIdentifier(hitId.get_compact());
}

firstMeasurementState()

std::optional< ActsTrk::TrackContainer::ConstTrackStateProxy > ActsTrk::firstMeasurementState	(	const xAOD::TrackParticle &	trkPart,
		const bool	skipOutlier = true )

Returns the track state proxy corresponding to the measurement that is closest to the defining track parameter.

The method retrieves the Acts track and returns the last measurement along the track which is not an outlier if toggled

Parameters

trkPart	Reference to the track particle made from the Acts chain
skipOutlier	Flag to ignore the outlier states

Definition at line 38 of file Decoration.cxx.

                                                  {
    auto actsTrk = getActsTrack(trkPart);
    if (!actsTrk) {
        return std::nullopt;
    }
    for (const auto state : actsTrk->trackStates()) {
        if ((state.typeFlags().isOutlier() && skipOutlier) ||
              !state.hasUncalibratedSourceLink()) {
            continue;
        }
        return state;
    }
    return std::nullopt;
}

firstTrackParameters()

std::optional< Acts::BoundTrackParameters > ActsTrk::firstTrackParameters	(	const xAOD::TrackParticle &	trkPart,
		const bool	skipOutlier = true )

Returns the first MeasurementState in form of Acts::BoundTrackParameters.

The logic follows the one from the firstMeasurementState

Parameters

trkPart	Reference to the track particle made from the Acts chain
skipOutlier	Flag to ignore the outlier states

Definition at line 65 of file Decoration.cxx.

                                                {
    auto firstTrkProxy = firstMeasurementState(trkPart, skipOutlier);
    if (!firstTrkProxy) {
        return std::nullopt;
    }
    return getActsTrack(trkPart)->createParametersFromState(*firstTrkProxy);
}

getActsTrack()

std::optional< TrackContainer::ConstTrackProxy > ActsTrk::getActsTrack

(

const xAOD::TrackParticle &

trkPart

)

Return the proxy to the Acts track from which the track particle was made frome.

Parameters

trkPart

The track particle containing a link to the Acts::Track

Definition at line 9 of file Decoration.cxx.

                                                                                            {
    static const SG::AuxElement::ConstAccessor<ElementLink<TrackContainer> > acc("actsTrack");
    static_assert(std::is_same<ElementLink<TrackContainer>::ElementConstReference,
                               std::optional<TrackContainer::ConstTrackProxy> >::value);
 
    if (!acc.isAvailable(trkPart) || !acc(trkPart).isValid()) {
        return std::nullopt;
    }
    return(*acc(trkPart));
 
}

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

getCaloExtension()

const CaloExtension * ActsTrk::getCaloExtension

(

const xAOD::TrackParticle &

track

)

Retrieve a pointer to the CaloExtension linked with the passed TrackParticle.

Note

Clients should ensure that they've scheduled a dependency on the caloExtensionLink decoration for the underlying track particle container.

Definition at line 11 of file Acts/ActsEvent/Root/CaloExtension.cxx.

                                                                          {
        static const SG::ConstAccessor<ElementLink<CaloExtensionContainer>> acc{"caloExtensionLink"};
        if (!acc.isAvailable(track)) {
            return nullptr;
        }
        const auto& link = acc(track);
        if (link.isValid()) {
            return *link;
        }
        return nullptr;
    }

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

lastMeasurementState()

std::optional< ActsTrk::TrackContainer::ConstTrackStateProxy > ActsTrk::lastMeasurementState	(	const xAOD::TrackParticle &	trkPart,
		const bool	skipOutlier = true )

Returns the track state proxy corresponding to the last measurement on track.

The method retrieves the Acts track and returns the last measurement along the track which is not an outlier if toggled

Parameters

trkPart	Reference to the track particle made from the Acts chain
skipOutlier	Flag to ignore the outlier states

Definition at line 21 of file Decoration.cxx.

                                                 {
    auto actsTrk = getActsTrack(trkPart);
    if (!actsTrk) {
        return std::nullopt;
    }
    for (const auto state : actsTrk->trackStatesReversed()) {
        if ((state.typeFlags().isOutlier() && skipOutlier) ||
              !state.hasUncalibratedSourceLink()) {
            continue;
        }
        return state;
    }
    return std::nullopt;
}

lastTrackParameters()

std::optional< Acts::BoundTrackParameters > ActsTrk::lastTrackParameters	(	const xAOD::TrackParticle &	trkPart,
		const bool	skipOutlier = true )

Returns the last MeasurementState in form of Acts::BoundTrackParameters.

The logic follows the one from the lastMeasurementState

Parameters

trkPart	Reference to the track particle made from the Acts chain
skipOutlier	Flag to ignore the outlier states

Definition at line 55 of file Decoration.cxx.

                                                {
    auto lastTrkProxy = lastMeasurementState(trkPart, skipOutlier);
    if (!lastTrkProxy) {
        return std::nullopt;
    }
    return getActsTrack(trkPart)->createParametersFromState(*lastTrkProxy);
}

lengthToActs()

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 37 of file UnitConverters.h.

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

lengthToAthena()

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 44 of file UnitConverters.h.

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

localPositionStrip2D()

std::tuple< Acts::Vector2, Amg::Vector2D, int, int > ActsTrk::localPositionStrip2D ( const Acts::GeometryContext & tgContext, const xAOD::UncalibratedMeasurement & measurement, const Acts::Surface * surface, const xAOD::SpacePoint * sp )

static

Definition at line 281 of file TrackStatePrinterTool.cxx.

  {
    auto *disc = dynamic_cast<const Acts::DiscSurface *>(surface);
    Acts::Vector2 loc{Acts::Vector2::Zero()};
    int est = 2; // est = 0 (estimated from SP), 1 (from module center), 2 (globalToLocal(center) failure), -1 (pixel)
    if (surface)
    {
      if (sp)
      {
        auto res = surface->globalToLocal(tgContext, sp->globalPosition().cast<double>(), Acts::Vector3::Zero());
        if (res.ok())
        {
          loc = res.value();
          est = 0;
        }
      }
 
      if (est != 0)
      {
        if (auto *annulus = dynamic_cast<const Acts::AnnulusBounds *>(&surface->bounds()))
        {
          loc[0] = 0.5 * (annulus->rMin() + annulus->rMax());
          est = 1;
        }
        else
        {
          auto res = surface->globalToLocal(tgContext, surface->center(tgContext), Acts::Vector3::Zero());
          if (res.ok())
          {
            loc = res.value();
            est = 1;
          }
        }
      }
    }
 
    const int measInd = disc ? 1 : 0;
    loc[measInd] = measurement.localPosition<1>()[0];
    if (disc)
    {
      Amg::Vector2D locTrk{disc->localPolarToCartesian(loc).reverse()};
      locTrk[0] = -locTrk[0];
      return {loc, locTrk, measInd, est};
    }
    else
    {
      return {loc, loc, measInd, est};
    }
  }

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 16 of file DetectorElementToActsGeometryIdMap.h.

                                                                                                          {
      assert( sizeof(xAOD::UncalibMeasType) <= sizeof(std::size_t) );
      assert( static_cast<std::size_t>( Acts::toUnderlying(meas_type)&((~DETELEMENT_HASH_MASK)>>DETELEMENT_TYPE_SHIFT)) == static_cast<std::size_t>(meas_type));
      assert( (identifier_hash & DETELEMENT_HASH_MASK) == identifier_hash);
      return (Acts::toUnderlying(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 515 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;
}

makeOutputContainer()

template<typename ClusterT, typename AuxContainerT, typename ContainerT = DataVector<ClusterT>>

std::pair< std::unique_ptr< ContainerT >, std::unique_ptr< AuxContainerT > > ActsTrk::makeOutputContainer	(	const EventContext &	ctx,
		int	n )

Definition at line 63 of file TracccMeasurementConverterAlg.cxx.

                                                              {
 
  DataPool<ClusterT> pool(ctx);
 
  auto cont = std::make_unique<ContainerT>(SG::VIEW_ELEMENTS,
                                           SG::ALWAYS_TRACK_INDICES);
  auto aux = std::make_unique<AuxContainerT>();
 
  pool.reserve(n);
  cont->push_new(n, [&pool]() { return pool.nextElementPtr(); });
  aux->resize(cont->size());
  cont->setStore(aux.get());
 
  return {std::move(cont), std::move(aux)};
}

matchPixelClusters()

void ActsTrk::matchPixelClusters	(	std::vector< const xAOD::PixelCluster * > &	monitored_list,
		std::vector< const xAOD::PixelCluster * > &	reference_list,
		const std::string &	module_id,
		std::vector< std::pair< const xAOD::PixelCluster *, const xAOD::PixelCluster * > > &	pairs )

Definition at line 79 of file ActsClusterComparisonAlg.cxx.

{
 
    // Extract RDO sets
    std::vector<std::set<Identifier>> monitored_rdo_sets;
    std::vector<std::set<Identifier>> reference_rdo_sets;
 
    for (const auto* c : monitored_list) {
        const auto& rdoListRange = c->rdoList();
        std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
        monitored_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
    }
 
    for (const auto* c : reference_list) {
        const auto& rdoListRange = c->rdoList();
        std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
        reference_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
    }
 
    // Match clusters
    std::vector<std::pair<int, int>> matched_pairs;
    std::vector<int> unmatched_monitored;
    std::set<int> unmatched_reference;
 
    for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
        unmatched_reference.insert(j);
    }
 
    for (size_t i = 0; i < monitored_rdo_sets.size(); ++i) {
 
        bool found_match = false;
        for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
            if (monitored_rdo_sets[i] == reference_rdo_sets[j]) {
                matched_pairs.emplace_back(i, j);
                pairs.emplace_back(monitored_list.at(i), reference_list.at(j));
                found_match = true;
                unmatched_reference.erase(j);
                break;
            }
        }
        if (!found_match) {
            unmatched_monitored.push_back(i);
        }
    }
 
    // Report mismatches
    if (!unmatched_monitored.empty() || !unmatched_reference.empty()) {
        std::cout << "\n[ERROR] Module " << module_id
                  << ": cluster mismatch detected!" << std::endl;
        if (!unmatched_monitored.empty()) {
            std::cout << "  Unmatched monitored clusters ("
                      << unmatched_monitored.size() << "):" << std::endl;
            for (int i : unmatched_monitored) {
                std::cout << "    - #" << i << std::endl;
            }
        }
        if (!unmatched_reference.empty()) {
            std::cout << "  Unmatched reference clusters (" << unmatched_reference.size()
                      << "):" << std::endl;
            for (int j : unmatched_reference) {
                std::cout << "    - #" << j << std::endl;
            }
        }
        std::cout
            << "------------------------------------------------------------"
            << std::endl;
    }
}

matchStripClusters()

void ActsTrk::matchStripClusters	(	std::vector< const xAOD::StripCluster * > &	monitored_list,
		std::vector< const xAOD::StripCluster * > &	reference_list,
		const std::string &	module_id,
		std::vector< std::pair< const xAOD::StripCluster *, const xAOD::StripCluster * > > &	pairs )

Definition at line 154 of file ActsClusterComparisonAlg.cxx.

{
 
    // Extract RDO sets
    std::vector<std::set<Identifier>> monitored_rdo_sets;
    std::vector<std::set<Identifier>> reference_rdo_sets;
 
    for (const auto* c : monitored_list) {
        const auto& rdoListRange = c->rdoList();
        std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
        monitored_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
    }
 
    for (const auto* c : reference_list) {
        const auto& rdoListRange = c->rdoList();
        std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
        reference_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
    }
 
    // Match clusters
    std::vector<std::pair<int, int>> matched_pairs;
    std::vector<int> unmatched_monitored;
    std::set<int> unmatched_reference;
 
    for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
        unmatched_reference.insert(j);
    }
 
    for (size_t i = 0; i < monitored_rdo_sets.size(); ++i) {
        bool found_match = false;
        for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
            if (monitored_rdo_sets[i] == reference_rdo_sets[j]) {
                matched_pairs.emplace_back(i, j);
                pairs.emplace_back(monitored_list.at(i), reference_list.at(j));
                found_match = true;
                unmatched_reference.erase(j);
                break;
            }
        }
        if (!found_match) {
            unmatched_monitored.push_back(i);
        }
    }
 
    // Report mismatches
    if (!unmatched_monitored.empty() || !unmatched_reference.empty()) {
        std::cout << "\n[ERROR] Module " << module_id
                  << ": cluster mismatch detected!" << std::endl;
        if (!unmatched_monitored.empty()) {
            std::cout << "  Unmatched monitored clusters ("
                      << unmatched_monitored.size() << "):" << std::endl;
            for (int i : unmatched_monitored) {
                std::cout << "    - #" << i << std::endl;
            }
        }
        if (!unmatched_reference.empty()) {
            std::cout << "  Unmatched reference clusters (" << unmatched_reference.size()
                      << "):" << std::endl;
            for (int j : unmatched_reference) {
                std::cout << "    - #" << j << std::endl;
            }
        }
        std::cout
            << "------------------------------------------------------------"
            << std::endl;
    }
}

operator<<() [1/3]

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

inline

Definition at line 21 of file TrackToTruthAssociationAlg.cxx.

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

operator<<() [2/3]

std::ostream & ActsTrk::operator<< ( std::ostream & ostr, const DetectorType type )

inline

Pipe the detector type to an outstream object.

Definition at line 100 of file GeometryDefs.h.

                                                                             {
        return (ostr<<detail::toString(type));
    }

operator<<() [3/3]

std::ostream & ActsTrk::operator<< ( std::ostream & ostr, const SystemEnvelope type )

inline

Pipe the Volume envelope to an oustream object.

Definition at line 104 of file GeometryDefs.h.

                                                                               {
        return (ostr<<detail::toString(type));
    }

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

printHeader()

void ActsTrk::printHeader ( int type, bool extra = false )

static

Definition at line 117 of file TrackStatePrinterTool.cxx.

  {
    std::cout << std::left
              << std::setw(5) << "Index" << ' '
              << std::setw(4) << "Type" << ' '
              << std::setw(21) << "SurfaceBounds" << ' ';
    if (type == 0)
    {
      std::cout << std::setw(22) << "GeometryId" << ' '
                << std::setw(20) << "ATLAS ID" << ' '
                << std::right
                << std::setw(10) << "loc0" << ' '
                << std::setw(10) << "loc1"
                << "  "
                << std::setw(9) << "R" << ' '
        << std::setw(9) << "Pos Z" << ' '
                << std::setw(9) << "phid" << ' '
                << std::setw(9) << "eta";
      if (extra)
      {
        std::cout << ' '
                  << std::setw(10) << "Trk loc0" << ' '
                  << std::setw(10) << "loc1"
                  << "  "
                  << std::setw(9) << "Trk R" << ' '
                  << std::setw(9) << "phid" << ' '
                  << std::setw(9) << "eta" << ' '
                  << std::setw(10) << "g2l loc0" << ' '
                  << std::setw(10) << "loc1";
      }
      std::cout << '\n';
      static std::atomic<int> kilroy = 0;
      if (!(kilroy++))
      {
        std::cout << "R (mm) and phi (degrees). Estimated local coordinate indicated by \"*\" (from SP), \"o\" (from module center), or \"#\" (globalToLocal(center) failure).";
        if (extra)
          std::cout << " Athena/ACTS comparison only shown if different.";
        std::cout << '\n';
      }
    }
    if (type == 1)
    {
      std::cout << std::setw(22) << "GeometryId/meas/stats" << ' '
                << std::right
                << std::setw(10) << "loc0" << ' '
                << std::setw(10) << "loc1" << ' '
                << std::setw(9) << "Pos R" << ' '
        << std::setw(9) << "Pos Z" << ' '
                << std::setw(9) << "phid" << ' '
                << std::setw(9) << "eta" << ' '
                << std::setw(9) << "q*pT" << ' '
                << std::setw(9) << "phid" << ' '
                << std::setw(9) << "eta" << ' '
                << std::setw(6) << "TrkLen" << ' '
                << std::setw(7) << "chi2" << ' '
                << std::setw(6) << "Flags" << '\n';
    }
  }

printMeasurement()

void ActsTrk::printMeasurement ( const Acts::GeometryContext & tgContext, const Acts::Surface * surface, const std::tuple< Acts::Vector2, Amg::Vector2D, int, int > & locData, bool compareMeasurementTransforms = false )

static

Definition at line 225 of file TrackStatePrinterTool.cxx.

  {
    auto &[loc, locTrk, measInd, est] = locData;
    int flag = est < 0 ? est : 2 * est + measInd;
    int flagTrk = est < 0 ? est : 2 * est;
    // indicates coordinate that is estimated: *=from SP, o=from module center, #=globalToLocal(center) failure
    static const std::map<int, const char *> estimated_flags{{-1, "  "},
                                                             {0, " *"},
                                                             {1, "* "},
                                                             {2, " o"},
                                                             {3, "o "},
                                                             {4, " #"},
                                                             {5, "# "}};
    printVec2(loc, estimated_flags.at(flag));
 
    if (surface)
    {
      // momentum direction doesn't seem to be needed for measurement surfaces (only LineSurface?)
      auto glob = surface->localToGlobal(tgContext, loc, Acts::Vector3::Zero());
      printVec3(glob);
 
      if (compareMeasurementTransforms) {
        const auto* acts_detector_element = getActsDetectorElement(surface);
        if (acts_detector_element) {
           const InDetDD::SiDetectorElement *detElem = dynamic_cast< const InDetDD::SiDetectorElement *>(acts_detector_element->upstreamDetectorElement());
 
           // if measInd=1: won't match because comparing x,y and R,phi, but at least not phi,R.
           // This is still useful for debugging because the next test also fails.
           printVec2(locTrk, (measInd == 1 ? loc.reverse() : loc), estimated_flags.at(flagTrk));
 
           if (detElem)
              {
                 auto globTrk = detElem->surface().localToGlobal(locTrk);
                 printVec3(globTrk, glob);
 
                 auto res = surface->globalToLocal(tgContext, globTrk, Acts::Vector3::Zero());
                 if (!res.ok())
                    {
                       std::cout << " ** " << res.error() << " **";
                    }
                 else
                    {
                       printVec2(res.value(), loc);
                    }
              }
        }
      }
 
    }
    std::cout << std::defaultfloat << std::setprecision(-1);
  }

printVec2() [1/2]

void ActsTrk::printVec2 ( const Acts::Vector2 & p, const Acts::Vector2 & cmp, const char * estimated = nullptr, int precision = 4 )

static

Definition at line 212 of file TrackStatePrinterTool.cxx.

  {
    if (((p - cmp).array().abs() >= 0.5 * std::pow(10.0, -precision)).any())
    {
      printVec2(p, estimated);
    }
    else
    {
      std::cout << std::setw(22 + (estimated ? 1 : 0)) << "";
    }
  }

printVec2() [2/2]

void ActsTrk::printVec2 ( const Acts::Vector2 & p, const char * estimated = nullptr )

static

Definition at line 201 of file TrackStatePrinterTool.cxx.

  {
    const char e0 = estimated ? estimated[0] : ' ';
    const char *e1 = estimated ? estimated + 1 : "";
    std::cout << std::fixed << ' '
              << std::setw(10) << std::setprecision(4) << p[0] << e0
              << std::setw(10) << std::setprecision(4) << p[1] << e1
              << std::defaultfloat << std::setprecision(-1);
  }

printVec3() [1/2]

void ActsTrk::printVec3 ( const Acts::Vector3 & p )

static

Definition at line 177 of file TrackStatePrinterTool.cxx.

  {
    std::cout << std::fixed << ' '
              << std::setw(9) << std::setprecision(3) << p.head<2>().norm() << ' '
          << std::setw(9) << std::setprecision(3) << p[2] << ' '
              << std::setw(9) << std::setprecision(3) << std::atan2(p[1], p[0]) / Acts::UnitConstants::degree << ' '
              << std::setw(9) << std::setprecision(5) << std::atanh(p[2] / p.norm())
              << std::defaultfloat << std::setprecision(-1);
  }

printVec3() [2/2]

void ActsTrk::printVec3 ( const Acts::Vector3 & p, const Acts::Vector3 & cmp, int precision = 3 )

static

Definition at line 188 of file TrackStatePrinterTool.cxx.

  {
    if (((p - cmp).array().abs() >= 0.5 * std::pow(10.0, -precision)).any())
    {
      printVec3(p);
    }
    else
    {
      std::cout << std::setw(30) << "";
    }
  }

rotateParams()

std::unique_ptr< Trk::TrackParameters > ActsTrk::rotateParams	(	const Trk::TrackParameters &	inPars,
		const Trk::Surface &	target )

Definition at line 49 of file ActsToTrkConverterTool.cxx.

                                                                              {
    const Amg::Vector3D& pos = inPars.position();
    const Amg::Vector3D& mom = inPars.momentum();
    using namespace Acts::PlanarHelper;
    
    const auto isect = intersectPlane(pos, mom.normalized(), target.normal(), target.center());
    std::optional<AmgSymMatrix(5)> cov{};
    if (inPars.covariance()) {
        AmgSymMatrix(5) rot {AmgSymMatrix(5)::Identity()};
        rot.block<2,2>(0,0) = AmgSymMatrix(2){Eigen::Rotation2D{90._degree}};
        cov = rot.transpose() * (*inPars.covariance()) * rot;
    }
    return target.createUniqueTrackParameters(isect.position(), mom,
                                              std::copysign(1., inPars.parameters()[Trk::qOverP]),
                                              std::move(cov));                     
}

sort_traccc_soa()

void ActsTrk::sort_traccc_soa	(	traccc::edm::silicon_cell_collection::device &	sorted_cells,
		traccc::edm::silicon_cell_collection::device const &	cells )

Definition at line 100 of file RDOtoTracccCellConverterCommons.cxx.

{
  using size_type = traccc::edm::silicon_cell_collection::buffer::size_type;
 
  std::vector<size_type> indices(cells.size());
  std::iota(indices.begin(), indices.end(), 0u);
 
  // Sort the indices according to the cells.
  std::sort(indices.begin(), indices.end(),
      [&](size_type lhs, size_type rhs) {
        return cells.at(lhs) < cells.at(rhs);
      });
 
  // Fill an output container with the sorted cells.
  size_type s = 0;
  for (size_type i : indices) {
    sorted_cells.at(s++) = cells.at(i);
  }
}

timeCovToActs()

template<std::floating_point T>

auto ActsTrk::timeCovToActs ( T athenaTCov )

inlineconstexpr

Converts a time covariance element from Athena to Acts units.

Parameters

athenaT

Time interval to convert

Definition at line 68 of file UnitConverters.h.

                                                      {
        using namespace Acts::UnitLiterals;
        constexpr auto sqr=[](double a) { return a*a;};
        constexpr auto timeCnv = static_cast<T>(sqr(1_ns / Gaudi::Units::ns));
        return timeCnv * athenaTCov;
    }

timeCovToAthena()

template<std::floating_point T>

double ActsTrk::timeCovToAthena ( T actsTCov )

inlineconstexpr

Converts a time covariance element from Acts to Athena units.

Parameters

actsT

Time interval to convert

Definition at line 77 of file UnitConverters.h.

                                                        {
        using namespace Acts::UnitLiterals;
        constexpr auto sqr=[](double a) { return a*a;};
        constexpr auto timeCnv = static_cast<T>(sqr(Gaudi::Units::ns/ 1_ns));
        return timeCnv * actsTCov;
    }

timeToActs()

template<std::floating_point T>

auto ActsTrk::timeToActs ( T athenaT )

inlineconstexpr

Converts a time unit from Athena to Acts units.

Parameters

athenaT

Time interval to convert

Definition at line 52 of file UnitConverters.h.

                                                {
        using namespace Acts::UnitLiterals;
        constexpr auto timeCnv = static_cast<T>(1_ns / Gaudi::Units::ns);
        return timeCnv * athenaT;
    }

timeToAthena()

template<std::floating_point T>

double ActsTrk::timeToAthena ( T actsT )

inlineconstexpr

Converts a time unit from Acts to Athena units.

Parameters

actsT

Time interval to convert

Definition at line 60 of file UnitConverters.h.

                                                  {
        using namespace Acts::UnitLiterals;
        constexpr auto timeCnv = static_cast<T>(Gaudi::Units::ns/ 1_ns);
        return timeCnv * actsT;
    }

toDetType()

DetectorType ActsTrk::toDetType

(

const xAOD::UncalibMeasType

mType

)

Converts the uncalibrated measurement type to a detector type.

Definition at line 10 of file EnumConversion.cxx.

                                                            {
        switch (mType) {
            using enum xAOD::UncalibMeasType;
            case PixelClusterType: return DetectorType::Pixel;
            case StripClusterType: return DetectorType::Sct;
            case MdtDriftCircleType: return DetectorType::Mdt;
            case RpcStripType: return DetectorType::Rpc;
            case TgcStripType: return DetectorType::Tgc;
            case MMClusterType: return DetectorType::Mm;
            case sTgcStripType: return DetectorType::sTgc;
            case HGTDClusterType: return DetectorType::Hgtd;
            case nTypes:
            case Other: return DetectorType::UnDefined;
        }
        return DetectorType::UnDefined;
    }

toMeasType()

xAOD::UncalibMeasType ActsTrk::toMeasType

(

const DetectorType

dType

)

Conversts the detector type to an uncalibrated measurement type.

Definition at line 26 of file EnumConversion.cxx.

                                                             {
        switch (dType) {
            using enum DetectorType;
            case Pixel: return xAOD::UncalibMeasType::PixelClusterType;  
            case Sct: return xAOD::UncalibMeasType::StripClusterType;  
            case Mdt: return xAOD::UncalibMeasType::MdtDriftCircleType;
            case Rpc: return xAOD::UncalibMeasType::RpcStripType;      
            case Tgc: return xAOD::UncalibMeasType::TgcStripType;      
            case Mm: return xAOD::UncalibMeasType::MMClusterType;     
            case sTgc: return xAOD::UncalibMeasType::sTgcStripType;     
            case Hgtd: return xAOD::UncalibMeasType::HGTDClusterType;
 
            default:
                throw std::runtime_error(std::format("toMeasType() - Unsupported {} type parsed", dType));
        }
        return xAOD::UncalibMeasType::nTypes;
    }

toTrkFitterType()

Trk::TrackInfo::TrackFitter ActsTrk::toTrkFitterType

(

const xAOD::TrackFitter

fType

)

Converts xAOD fitter type to Trk fitter type.

Definition at line 43 of file EnumConversion.cxx.

                                                                         {
        switch (fType) {
            using enum xAOD::TrackFitter;
            case Unknown: return Trk::TrackInfo::TrackFitter::Unknown;
            case iPatTrackFitter: return Trk::TrackInfo::TrackFitter::iPatTrackFitter;
            case xKalman: return Trk::TrackInfo::TrackFitter::xKalman;
            case GaussianSumFilter: return Trk::TrackInfo::TrackFitter::GaussianSumFilter;
            case GlobalChi2Fitter: return Trk::TrackInfo::TrackFitter::GlobalChi2Fitter;
            case DistributedKalmanFilter: return Trk::TrackInfo::TrackFitter::DistributedKalmanFilter;
            case DeterministicAnnealingFilter: return Trk::TrackInfo::TrackFitter::DeterministicAnnealingFilter;
            case KalmanFitter: return Trk::TrackInfo::TrackFitter::KalmanFitter;
            case KalmanDNAFitter: return Trk::TrackInfo::TrackFitter::KalmanDNAFitter;
            case MuonboyFitter: return Trk::TrackInfo::TrackFitter::MuonboyFitter;
 
            default: 
                throw std::runtime_error("toTrkFitterType() - Unsupported type parsed");
        }
    }

velocityToActs()

double ActsTrk::velocityToActs ( const double athenaV )

inlineconstexpr

Converts a velocity from Athena to Acts units.

Parameters

athenaV

Velocity to convert

Definition at line 85 of file UnitConverters.h.

                                                                 {
        return athenaV  / timeToActs(1.);
    }

Variable Documentation

DETELEMENT_HASH_MASK

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

constexpr

Definition at line 14 of file DetectorElementToActsGeometryIdMap.h.

DETELEMENT_TYPE_SHIFT

unsigned int ActsTrk::DETELEMENT_TYPE_SHIFT = 28

constexpr

Definition at line 13 of file DetectorElementToActsGeometryIdMap.h.

NHitCounter

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

unsigned int ActsTrk::NTruthParticlesPerMeasurement = 5

constexpr

Definition at line 14 of file MeasurementToTruthParticleAssociation.h.

NTruthParticlesPerTrack

unsigned int ActsTrk::NTruthParticlesPerTrack = 5

constexpr

Definition at line 20 of file TrackToTruthParticleAssociation.h.

ONE_TWELFTH

double ActsTrk::ONE_TWELFTH = 1./12.

constexpr

Definition at line 19 of file StripClusteringTool.cxx.

oneStripSF

float ActsTrk::oneStripSF = 1.1025

constexpr

Definition at line 20 of file StripClusteringTool.cxx.

TrackFindingValidationDebugHists

bool ActsTrk::TrackFindingValidationDebugHists = false

constexpr

Definition at line 40 of file TrackTruthMatchingBaseAlg.h.

TrackFindingValidationDetailedStat

bool ActsTrk::TrackFindingValidationDetailedStat = true

constexpr

Definition at line 41 of file TrackTruthMatchingBaseAlg.h.

TrackToTruthParticleAssociationDebugHists

bool ActsTrk::TrackToTruthParticleAssociationDebugHists = false

constexpr

Definition at line 43 of file TrackToTruthAssociationAlg.h.

TruthParticleHitCountDebugHists

bool ActsTrk::TruthParticleHitCountDebugHists = false

constexpr

Definition at line 40 of file TruthParticleHitCountAlg.h.

twoStripSF

float ActsTrk::twoStripSF = 0.0729

constexpr

Definition at line 21 of file StripClusteringTool.cxx.