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	Cache
namespace	detail
	Athena definition of the Eigen plugin.
namespace	details
namespace	ParticleHypothesis
namespace	ScoreBasedSolverCutsImpl

Classes
class	ActsInspectTruthContentAlg
class	ActsMuonTrackingGeometryTest
	Extrapolation test for the ActsMuonTrackingGeometry for gen3. More...
class	ActsToTrkConverterTool
class	ActsToTrkConvertorAlg
class	ActsToXAODTrackConverterAlg
class	ActsTrackStateOnSurfaceDecoratorAlg
class	ActsVolumeIdToDetectorElementCollectionMap
class	ActsVolumeIdToDetectorElementCollectionMappingAlg
class	AdaptiveMultiPriVtxFinderTool
class	AlignStoreProviderAlg
class	AmbiguityResolutionAlg
class	AuxiliaryMeasurementHandler
	Utility class to handle the creation of the Auxiliary measurement used in an Acts track fit This class declares the additionally written xAOD::AuxiliaryMeasurementContainers to the AvalancheScheduler. More...
class	CaloBasedRoICreatorTool
class	CaloBlueprintNodeBuilder
	Builds the Calo Blueprint Node. More...
class	ClusterizationAlg
class	ConstTrackContainerHandlesHelper
class	CoreStripSpacePointFormationTool
	Tool to produce strip space points using ACTS SP builder. More...
struct	DataLinkHolder
class	DataPreparationAlg
class	DetectorAlignCondAlg
class	DetectorAlignStore
struct	DetectorElementToActsGeometryIdMap
class	DummyRDOList
class	EstimatedTrackParamsAnalysisAlg
class	ExtrapolationTool
class	FullScanRoICreatorTool
class	GaussianSumFitterTool
class	GbtsSeedingTool
class	GeometryContext
class	GeometryContextAlg
class	GlobalChiSquareFitterTool
class	GridTripletSeedingAlg
class	GridTripletSeedingTool
struct	has_rdoList
struct	has_rdoList< Object, std::void_t< rdoListFunc_t< Object > > >
class	HgtdClusterAnalysisAlg
class	HgtdClusterDataPreparationAlg
class	HgtdClusteringTool
class	HgtdClusterizationAlg
class	HgtdClusterToTruthAssociationAlg
class	HgtdClusterValidationPlots
class	HgtdTimedClusteringTool
class	HGTDTrackExtensionAlg
class	HGTDTruthTrackDecorationAlg
class	HitCounterArray
class	HitCountsPerTrack
	Container for hit counts per track Contains hit counts per associated truth particle and the total hit counts As last element in the container. More...
class	IActsToTrkConverterTool
	Conversion tool interface to translate surfaces & track parameters between the Acts & Trk realm. More...
class	IBlueprintNodeBuilder
	Interface for the Blueprint node builder This interface is used to build a Blueprint node for the Acts tracking geometry. More...
class	IDetectorElement
	Base class interface for the actual readout elements. More...
class	IDetectorElementBase
	base class interface providing the bare minimal interface extension. More...
class	IExtrapolationTool
	Tool to extrapolate bound track parameters. More...
class	IFitterTool
	Generic interface class to fit xAOD::Uncalibrated measurements to (multi)-trajectories. More...
class	IHGTDClusteringTool
class	IMeasurementSelector
class	IndexingPolicy
class	IOnBoundStateCalibratorTool
class	IOnTrackCalibratorTool
class	IPixelClusteringTool
class	IPixelSpacePointFormationTool
	Base class for pixel space point formation tool. More...
class	IProtoTrackCreatorTool
class	IRoICreatorTool
class	ISeedingTool
class	IStripClusteringTool
class	IStripSpacePointFormationTool
class	IterativePriVtxFinderTool
class	ITkAlignMonResidualsAlg
class	ITkAnalogueClusteringTool
class	ItkBlueprintNodeBuilder
	Helper class to build the ItkBlueprint node It adds the system as a node to the Blueprint. More...
class	ITkStripCalibrationTool
class	ITrackingGeometrySvc
class	ITrackingGeometryTool
	Geometry helper tool extending the Tracking geometry service by the data dependency to fetch the geometry context from StoreGate. More...
class	ITrackParamsEstimationTool
class	KalmanFitterTool
struct	MeasurementCalibrator
struct	MeasurementParameterMap
class	MeasurementToTrackParticleDecorationAlg
class	MeasurementToTruthAssociationAlg
	Algorithm template to associate measurements of a certain type to a xAOD truth particles using a sim data collection where the sim data collection contains associates RDOs to truth particles and there energy/charge disposition. More...
class	MeasurementToTruthParticleAssociation
class	MultiTrajectory
	Read only version of MTJ The implementation is separate as the details are significantly different and in addition only const methods are ever needed. More...
class	MuonBlueprintNodeBuilder
	Helper class to build a Blueprint node of the muon system. More...
class	MutableMultiTrajectory
	Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends. More...
struct	MutablePersistentTrackContainer
class	MutableTrackContainerHandlesHelper
class	MutableTrackSummaryContainer
class	NoDeletePtr
class	OrthogonalSeedingTool
class	PersistentTrackContainer
class	PhysValTool
class	PixelCacheClusterizationAlg
class	PixelCacheSpacePointFormationAlg
class	PixelClusterAnalysisAlg
class	PixelClusterCacheDataPreparationAlg
class	PixelClusterDataPreparationAlg
class	PixelClusteringTool
class	PixelClusterizationAlg
class	PixelClusterSiHitDecoratorAlg
class	PixelClusterToTruthAssociationAlg
class	PixelClusterTruthDecoratorAlg
class	PixelClusterValidationPlots
class	PixelSpacePointFormationAlg
	This version of PixelSpacePointFormationAlg uses xAOD pixel clusters to find space points in the ITk pixeldetectors. More...
class	PixelSpacePointFormationAlgBase
class	PixelSpacePointFormationTool
	Tool to produce pixel space points. More...
class	PixelSpacePointValidationPlots
class	PrdAssociationAlg
class	PrepRawDataAssociation
struct	ProtoTrack
class	ProtoTrackCreationAndFitAlg
class	ProtoTrackReportingAlg
	Very lightweight algorithm to print out the results of the EF track finding. More...
class	RandomProtoTrackCreatorTool
class	ReFitterAlg
class	RegionsOfInterestCreatorAlg
class	ScoreBasedAmbiguityResolutionAlg
struct	Seed
class	SeedAnalysisAlg
struct	SeedContainer
class	SeedingAlg
class	SeedingAlgorithmAnalysisAlg
class	SeedingTool
class	SeedsToTrackParamsAlg
class	SeedToTrackAnalysisAlg
class	SeedToTrackCnvAlg
class	SiSpacePointsSeedMaker
class	SpacePointAnalysisAlg
class	SpacePointCacheDataPreparationAlg
class	SpacePointCollector
class	SpacePointDataPreparationAlg
struct	SpacePointIndexSubset
class	StripCacheClusterizationAlg
class	StripCacheSpacePointFormationAlg
class	StripClusterAnalysisAlg
class	StripClusterCacheDataPreparationAlg
class	StripClusterDataPreparationAlg
class	StripClusteringTool
class	StripClusterizationAlg
class	StripClusterSiHitDecoratorAlg
class	StripClusterToTruthAssociationAlg
class	StripClusterTruthDecoratorAlg
class	StripClusterValidationPlots
class	StripInformationHelper
struct	StripSP
class	StripSpacePointFormationAlg
class	StripSpacePointFormationAlgBase
	This version of StripSpacePointFormationAlgBase uses xAOD strip clusters to find space points in the ITk strip detectors. More...
class	StripSpacePointFormationTool
class	StripSpacePointValidationPlots
class	SurfaceCache
	: Helper class to connect the aligned transformations of each active sensor(layer) with the Acts::Surfaces. More...
class	TestRoICreatorTool
class	TrackAnalysisAlg
class	TrackContainer
class	TrackContainerReader
class	TrackExtensionAlg
class	TrackFindingAlg
class	TrackFindingBaseAlg
class	TrackFindingValidationAlg
class	TrackParamsEstimationTool
class	TrackParticleAnalysisAlg
class	TrackParticleTruthDecorationAlg
class	TrackStatePrinterTool
class	TrackSummaryContainer
class	TrackToTrackParticleCnvAlg
class	TrackToTruthAssociationAlg
class	TrackToTruthParticleAssociation
class	TrackTruthMatchingBaseAlg
class	TransformCache
class	TransformCacheDetEle
class	TrkToActsConvertorAlg
	Algorithm convert Trk::Track to ACTS multistate objects. More...
class	TruthGuidedProtoTrackCreatorTool
class	TruthParticleHitCountAlg

Typedefs
using	staticNodePtr = std::shared_ptr<Acts::Experimental::StaticBlueprintNode>
using	surfacePtr = std::shared_ptr<Acts::Surface>
using	MuonChamberSet = MuonGMR4::MuonDetectorManager::MuonChamberSet
using	MuonSectorSet = MuonGMR4::MuonDetectorManager::MuonSectorSet
using	StIdx = Muon::MuonStationIndex::StIndex
using	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	ATLASSourceLink = const Trk::MeasurementBase *
using	ATLASUncalibSourceLink = const xAOD::UncalibratedMeasurement *
using	DetectorElementKey = unsigned int
using	TicketCounterArr = DetectorAlignStore::TrackingAlignStore::TicketCounterArr
using	ReturnedTicketArr = DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr
using	ReturnedHintArr = DetectorAlignStore::TrackingAlignStore::ReturnedHintArr
using	SurfaceCacheSet = std::set<std::unique_ptr<SurfaceCache>, std::less<>>
using	AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor
using	DefaultTrackStateCreator = Acts::TrackStateCreator<ActsTrk::detail::UncalibSourceLinkAccessor::Iterator,detail::RecoTrackContainer>
template<typename Object>
using	rdoListFunc_t = decltype(std::declval<Object>().rdoList())

Enumerations
enum	NeighbourIndices { ThisOne , Opposite , PhiMinus , PhiPlus , EtaMinus , EtaPlus , nNeighbours }
	Total number of neightbours and indices. More...
enum class	DetectorType : unsigned short { Pixel , Sct , Trt , Hgtd , Mdt , Rpc , Tgc , Csc , Mm , sTgc , UnDefined }
	Simple enum to Identify the Type of the ACTS sub detector. More...

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 int	getCellRow (const typename PixelClusteringTool::Cell &cell)
static int	getCellColumn (const typename PixelClusteringTool::Cell &cell)
static void	clusterReserve (PixelClusteringTool::Cluster &cl, std::size_t n)
static void	clusterAddCell (PixelClusteringTool::Cluster &cl, const PixelClusteringTool::Cell &cell)
static int	getCellColumn (const StripClusteringTool::Cell &cell)
static void	clusterReserve (StripClusteringTool::Cluster &cl, std::size_t n)
static void	clusterAddCell (StripClusteringTool::Cluster &cl, const StripClusteringTool::Cell &cell)
static std::pair< Eigen::Matrix< float, 1, 1 >, Eigen::Matrix< float, 3, 1 > >	computePosition (const StripClusteringTool::Cluster &cluster, std::size_t size, double lorentzShift, const IStripClusteringTool::IDHelper &stripID, const InDetDD::SiDetectorElement &element, const InDetDD::SiDetectorDesign &design, bool isITk)
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.
static void	ActsMeasurementCheck (const Acts::GeometryContext &gctx, const Trk::MeasurementBase &measurement, const Acts::Surface &surface, const Acts::BoundVector &loc)
static void	ActsTrackParameterCheck (const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext &gctx, const Acts::BoundSquareMatrix &covpc, const Acts::BoundVector &targetPars, const Acts::BoundSquareMatrix &targetCov, const Trk::PlaneSurface *planeSurface)
const xAOD::UncalibratedMeasurement &	getUncalibratedMeasurement (const ATLASUncalibSourceLink &source_link)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index, const EventContext &ctx)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer container, const xAOD::UncalibratedMeasurement measurement, const EventContext &ctx)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurement *measurement)
float	localXFromSourceLink (const ATLASUncalibSourceLink &source_link)
float	localYFromSourceLink (const ATLASUncalibSourceLink &source_link)
DetectorElementKey	makeDetectorElementKey (xAOD::UncalibMeasType meas_type, unsigned int identifier_hash)
Acts::GeometryIdentifier	getSurfaceGeometryIdOfMeasurement (const DetectorElementToActsGeometryIdMap &detector_element_to_geoid, const xAOD::UncalibratedMeasurement &measurement)
std::string	to_string (const DetectorType &type)
bool	operator< (const std::unique_ptr< SurfaceCache > &a, const std::unique_ptr< SurfaceCache > &b)
	Comparison operators.
bool	operator< (const IdentifierHash &a, const std::unique_ptr< SurfaceCache > &b)
bool	operator< (const std::unique_ptr< SurfaceCache > &a, const IdentifierHash &b)
void	encodeSurface (xAOD::TrackSurfaceAuxContainer backend, size_t index, const Acts::Surface surface, const Acts::GeometryContext &geoContext)
	Prepares persistifiable representation of surface into xAOD::TrackSurface object.
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)
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.
constexpr double	timeToActs (const double athenaT)
	Converts a time unit from Athena to Acts units.
constexpr double	timeToAthena (const double actsT)
	Converts a time unit from Acts to Athena 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.
template<typename T>
std::underlying_type_t< T >	to_underlying (T val)
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)
static constexpr float	s_toTesla = 0.299785832
constexpr bool	TrackToTruthParticleAssociationDebugHists = false
constexpr bool	TrackFindingValidationDebugHists = false
constexpr bool	TrackFindingValidationDetailedStat = true
constexpr bool	TruthParticleHitCountDebugHists = false

Detailed Description

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

copied from InDetPhysValMonitoring/src/safeDecorator.h

Put athena Eigen inlcude first.

: The NoDeletePtr is a shared_ptr with disabled deleter.

Header file to manage the common inlcudes.

Includes the GeoPrimitives.

Load ATLAS Eigen library with custom geometry functions.

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 ActsFromGeoAlignStore is an adaptor to go from the GeoModel world caching the rigid transformations of the detector elements to the Acts world where transformations

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

Then load the Acts TypeDef definitions for Eigen

In AthSimulation, the Acts core library is not available yet

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

forward declarations of the classes defined in the package

Typedef Documentation

◆ ATLASSourceLink

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

Definition at line 23 of file ATLASSourceLink.h.

◆ ATLASUncalibSourceLink

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

Definition at line 24 of file ATLASSourceLink.h.

◆ AtlUncalibSourceLinkAccessor

using ActsTrk::AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor

Definition at line 42 of file TrackFindingAlg.h.

◆ BoundTrackParametersContainer

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

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

◆ ConstCovariance

using ActsTrk::ConstCovariance = 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

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

Definition at line 43 of file TrackFindingAlg.h.

◆ DetectorElementKey

using ActsTrk::DetectorElementKey = unsigned int

Definition at line 19 of file DetectorElementToActsGeometryIdMap.h.

◆ IndexType

using ActsTrk::IndexType = std::uint32_t

Definition at line 14 of file Decoration.h.

◆ MuonChamberSet

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

Definition at line 42 of file MuonBlueprintNodeBuilder.h.

◆ MuonSectorSet

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

Definition at line 43 of file MuonBlueprintNodeBuilder.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 28 of file PersistentTrackContainer.h.

◆ PersistentTrackStateBackend

using ActsTrk::PersistentTrackStateBackend = ActsTrk::MultiTrajectory

Definition at line 17 of file PersistentTrackContainer.h.

◆ ProtoTrackCollection

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

Definition at line 12 of file ProtoTrackCollection.h.

◆ rdoListFunc_t

template<typename Object>

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

Definition at line 94 of file MeasurementToTruthAssociationAlg.h.

◆ ReturnedHintArr

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

Definition at line 16 of file DetectorAlignStore.cxx.

◆ ReturnedTicketArr

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

Definition at line 15 of file DetectorAlignStore.cxx.

◆ staticNodePtr

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

Definition at line 40 of file MuonBlueprintNodeBuilder.h.

◆ StIdx

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

Definition at line 44 of file MuonBlueprintNodeBuilder.h.

◆ StoredSurface

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

Definition at line 66 of file MultiTrajectory.h.

◆ SurfaceCacheSet

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

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

◆ surfacePtr

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

Definition at line 41 of file MuonBlueprintNodeBuilder.h.

◆ TicketCounterArr

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

Definition at line 14 of file DetectorAlignStore.cxx.

◆ 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

◆ DetectorType

enum class ActsTrk::DetectorType : unsigned short

strong

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

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

Definition at line 17 of file GeometryDefs.h.

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

◆ NeighbourIndices

enum ActsTrk::NeighbourIndices

Total number of neightbours and indices.

Enumerator
ThisOne
Opposite
PhiMinus
PhiPlus
EtaMinus
EtaPlus
nNeighbours

Definition at line 13 of file StripInformationHelper.h.

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

ActsTrk::PhiMinus

@ PhiMinus

Definition StripInformationHelper.h:13

ActsTrk::nNeighbours

@ nNeighbours

Definition StripInformationHelper.h:13

ActsTrk::ThisOne

@ ThisOne

Definition StripInformationHelper.h:13

ActsTrk::EtaMinus

@ EtaMinus

Definition StripInformationHelper.h:13

ActsTrk::Opposite

@ Opposite

Definition StripInformationHelper.h:13

ActsTrk::EtaPlus

@ EtaPlus

Definition StripInformationHelper.h:13

ActsTrk::PhiPlus

@ PhiPlus

Definition StripInformationHelper.h:13

Function Documentation

◆ actsLevelVector()

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

Definition at line 9 of file LoggerUtils.cxx.

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

◆ ActsMeasurementCheck()

void ActsTrk::ActsMeasurementCheck	(	const Acts::GeometryContext &	gctx,
		const Trk::MeasurementBase &	measurement,
		const Acts::Surface &	surface,
		const Acts::BoundVector &	loc )

static

Definition at line 577 of file ActsToTrkConverterTool.cxx.

                                                            {
  const Trk::Surface &surf = measurement.associatedSurface();
  // only check Annulus for the moment
  if (surf.bounds().type() != Trk::SurfaceBounds::Annulus) {
    return;
  }
  const auto *bounds = dynamic_cast<const Trk::AnnulusBounds *>(&surf.bounds());
  if (bounds == nullptr) {
    throw std::runtime_error{"Annulus but not XY"};
  }
 
  Amg::Vector2D locxy = loc.head<2>();
 
  Acts::ActsMatrix<2, 2> covxy = measurement.localCovariance();
 
  Amg::Vector3D global = surf.localToGlobal(locxy, Amg::Vector3D{});
  Acts::Vector2 locpc;
  if (auto res = surface.globalToLocal(gctx, global, Acts::Vector3{});
      res.ok()) {
    locpc = *res;
  } else {
    throw std::runtime_error{"Global position not on target surface"};
  }
 
  // use ACTS jacobian math to convert cluster covariance from cartesian to
  // polar
  auto planeSurface =
      Acts::Surface::makeShared<Acts::PlaneSurface>(surf.transform());
  Acts::BoundVector locxypar;
  locxypar.head<2>() = locxy;
  locxypar[2] = 0;
  locxypar[3] = M_PI_2;
  locxypar[4] = 1;
  locxypar[5] = 1;
  Acts::FreeVector globalxypar = Acts::transformBoundToFreeParameters(
  *planeSurface, gctx, locxypar);
  auto boundToFree = planeSurface->boundToFreeJacobian(
        gctx, globalxypar.segment<3>(Acts::eFreePos0),
        globalxypar.segment<3>(Acts::eFreeDir0));
  Acts::ActsSquareMatrix<2> xyToXyzJac = boundToFree.topLeftCorner<2, 2>();
 
  Acts::BoundVector locpcpar;
  locpcpar.head<2>() = locpc;
  locpcpar[2] = 0;
  locpcpar[3] = M_PI_2;
  locpcpar[4] = 1;
  locpcpar[5] = 1;
  Acts::FreeVector globalpcpar = Acts::transformBoundToFreeParameters(
  surface, gctx, locpcpar);
 
  boundToFree = surface.boundToFreeJacobian(
        gctx, globalpcpar.segment<3>(Acts::eFreePos0),
  globalpcpar.segment<3>(Acts::eFreeDir0));
  Acts::ActsSquareMatrix<2> pcToXyzJac = boundToFree.topLeftCorner<2, 2>();
  Acts::ActsSquareMatrix<2> xyzToPcJac = pcToXyzJac.inverse();
 
  // convert cluster covariance
  Acts::ActsMatrix<2, 2> covpc = covxy;
  covpc = xyToXyzJac * covpc * xyToXyzJac.transpose();
  covpc = xyzToPcJac * covpc * xyzToPcJac.transpose();
 
  std::mt19937 gen{42 + surface.geometryId().value()};
  std::normal_distribution<double> normal{0, 1};
  std::uniform_real_distribution<double> uniform{-1, 1};
 
  Acts::ActsMatrix<2, 2> lltxy = covxy.llt().matrixL();
  Acts::ActsMatrix<2, 2> lltpc = covpc.llt().matrixL();
 
  for (size_t i = 0; i < 1e4; i++) {
    std::cout << "ANNULUS COV: ";
    std::cout << surface.geometryId();
 
    Amg::Vector2D rnd{normal(gen), normal(gen)};
 
    // XY
    {
      Amg::Vector2D xy = lltxy * rnd + locxy;
      Amg::Vector3D xyz = surf.localToGlobal(xy);
      std::cout << "," << xy.x() << "," << xy.y();
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
    // PC
    {
      // Amg::Vector2D xy = lltpc * rnd + loc.head<2>();
      Amg::Vector2D rt = lltpc * rnd + locpc;
      Amg::Vector3D xyz = surface.localToGlobal(gctx, rt, Acts::Vector3{});
      // Amg::Vector3D xyz = surface.transform(gctx).rotation() *
      // Acts::Vector3{rt.x(), rt.y(), 0};
 
      std::cout << "," << rt.x() << "," << rt.y();
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
 
    std::cout << std::endl;
  }
}

◆ ActsTrackParameterCheck()

void ActsTrk::ActsTrackParameterCheck	(	const Acts::BoundTrackParameters &	actsParameter,
		const Acts::GeometryContext &	gctx,
		const Acts::BoundSquareMatrix &	covpc,
		const Acts::BoundVector &	targetPars,
		const Acts::BoundSquareMatrix &	targetCov,
		const Trk::PlaneSurface *	planeSurface )

static

Definition at line 677 of file ActsToTrkConverterTool.cxx.

                                         {
 
  std::cout << "ANNULUS PAR COV: ";
  std::cout << actsParameter.referenceSurface().geometryId();
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      std::cout << "," << covpc(i, j);
    }
  }
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      std::cout << "," << targetCov(i, j);
    }
  }
  std::cout << std::endl;
 
  std::mt19937 gen{4242 +
                   actsParameter.referenceSurface().geometryId().value()};
  std::normal_distribution<double> normal{0, 1};
 
  Acts::ActsMatrix<2, 2> lltxy =
      targetCov.topLeftCorner<2, 2>().llt().matrixL();
  Acts::ActsMatrix<2, 2> lltpc = covpc.topLeftCorner<2, 2>().llt().matrixL();
 
  for (size_t i = 0; i < 1e4; i++) {
    std::cout << "ANNULUS PAR: ";
    std::cout << actsParameter.referenceSurface().geometryId();
 
    Acts::ActsVector<2> rnd;
    rnd << normal(gen), normal(gen);
 
    // XY
    {
      Acts::ActsVector<2> xy =
          lltxy.topLeftCorner<2, 2>() * rnd + targetPars.head<2>();
      Amg::Vector3D xyz;
      planeSurface->localToGlobal(Amg::Vector2D{xy.head<2>()}, Amg::Vector3D{},
                                  xyz);
      for (unsigned int i = 0; i < 2; i++) {
        std::cout << "," << xy[i];
      }
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
    // PC
    {
      Acts::ActsVector<2> rt = lltpc.topLeftCorner<2, 2>() * rnd +
                               actsParameter.parameters().head<2>();
      Amg::Vector3D xyz = actsParameter.referenceSurface().localToGlobal(
          gctx, Acts::Vector2{rt.head<2>()}, Acts::Vector3{});
 
      for (unsigned int i = 0; i < 2; i++) {
        std::cout << "," << rt[i];
      }
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
 
    std::cout << std::endl;
  }
}

◆ 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 ActsDetectorElement *
           acts_detector_element = dynamic_cast<const ActsDetectorElement *>(measurement_surface->associatedDetectorElement());
        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 {};
  }

◆ clusterAddCell() [1/2]

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

inlinestatic

Definition at line 33 of file PixelClusteringTool.cxx.

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

◆ clusterAddCell() [2/2]

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

static

Definition at line 40 of file StripClusteringTool.cxx.

{
    cl.ids.push_back(cell.id.get_compact());
    if (cl.ids.size() < (sizeof(cl.hitsInThirdTimeBin) * 8)) {
      cl.hitsInThirdTimeBin |= cell.timeBits.test(0) << cl.ids.size();
    }
}

◆ clusterReserve() [1/2]

void ActsTrk::clusterReserve	(	PixelClusteringTool::Cluster &	cl,
		std::size_t	n )

inlinestatic

Definition at line 27 of file PixelClusteringTool.cxx.

  {
    cl.ids.reserve(n);
    cl.tots.reserve(n);
  }  

◆ clusterReserve() [2/2]

void ActsTrk::clusterReserve	(	StripClusteringTool::Cluster &	cl,
		std::size_t	n )

inlinestatic

Definition at line 32 of file StripClusteringTool.cxx.

{
  cl.ids.reserve(n);
} 

◆ computePosition()

std::pair< Eigen::Matrix< float, 1, 1 >, Eigen::Matrix< float, 3, 1 > > ActsTrk::computePosition	(	const StripClusteringTool::Cluster &	cluster,
		std::size_t	size,
		double	lorentzShift,
		const IStripClusteringTool::IDHelper &	stripID,
		const InDetDD::SiDetectorElement &	element,
		const InDetDD::SiDetectorDesign &	design,
		bool	isITk )

static

Definition at line 200 of file StripClusteringTool.cxx.

{
 
    Identifier ids_front(cluster.ids.front());
    Identifier ids_back(cluster.ids.back());
    InDetDD::SiCellId frontId = stripID.strip(ids_front);
    InDetDD::SiLocalPosition pos = design.localPositionOfCell(frontId);
    if (size > 1) {
      InDetDD::SiCellId backId = stripID.strip(ids_back);
    InDetDD::SiLocalPosition backPos =
        design.localPositionOfCell(backId);
    pos = 0.5 * (pos + backPos);
    }
 
    // update the xPhi position
    pos.xPhi( pos.xPhi() + lorentzShift );
    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));
}

◆ convertDirFromActs()

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

inline

Converts a direction vector from acts units into athena units.

Parameters

actsDir Unit normalized vector to convert

Definition at line 68 of file UnitConverters.h.

                                                                      {
        return actsDir;
    }

◆ convertDirToActs()

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

inline

Converts a direction vector from athena units into acts units.

Parameters

athenaDir Unit normalized vector to convert

Definition at line 63 of file UnitConverters.h.

                                                                      {
        return athenaDir;
    }

◆ convertMomFromActs()

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

inline

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

Parameters

actsMom The four momentum vector from Acts

Definition at line 109 of file UnitConverters.h.

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

◆ convertMomToActs()

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

inline

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

Parameters

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

Definition at line 97 of file UnitConverters.h.

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

◆ convertPosFromActs()

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

inline

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

Parameters

actsPos Position from the Acts framework

Definition at line 86 of file UnitConverters.h.

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

◆ convertPosToActs()

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

inline

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

Parameters

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

Definition at line 74 of file UnitConverters.h.

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

◆ createDecoratorKeys()

template<class T_Parent, class T_Cont>

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

Definition at line 49 of file decoratorUtils.h.

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

◆ createDecorators()

template<class T_Cont, class T>

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

Definition at line 31 of file decoratorUtils.h.

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

◆ decodeSurface() [1/3]

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

Definition at line 91 of file SurfaceEncoding.cxx.

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

◆ decodeSurface() [2/3]

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

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

Definition at line 136 of file SurfaceEncoding.cxx.

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

◆ decodeSurface() [3/3]

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

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

Definition at line 141 of file SurfaceEncoding.cxx.

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

◆ encodeSurface() [1/3]

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

Definition at line 20 of file SurfaceEncoding.cxx.

                                                          {
  // return if surf is a nullptr
  if (!surface) {
    return;
  }
  switch (surface->type()){
     using enum Acts::Surface::SurfaceType;
     case Cone:
        surfaceType = xAOD::SurfaceType::Cone;
        break;
      case Cylinder: 
        surfaceType = xAOD::SurfaceType::Cylinder;
        break;
      case Disc:
        surfaceType = xAOD::SurfaceType::Disc;
        break;
      case Perigee:
        surfaceType = xAOD::SurfaceType::Perigee;
        break;
      case Plane:
        surfaceType = xAOD::SurfaceType::Plane;
        break;
      case Straw: 
        surfaceType = xAOD::SurfaceType::Straw;
        break;
      case Curvilinear:
        surfaceType = xAOD::SurfaceType::Curvilinear;
        break;
      case Other:
        surfaceType = xAOD::SurfaceType::Other;
        break;
  }
 
  Acts::RotationMatrix3 lRotation =
      surface->transform(geoContext).rotation();
  Acts::Vector3 eulerAngles = lRotation.eulerAngles(2, 1, 0);
  Acts::Vector3 lTranslation = surface->center(geoContext);
 
  for (int i = 0; i < 3; ++i) {
    rotation.push_back(eulerAngles[i]);
    translation.push_back(lTranslation[i]);
  }
  // copy and transform double->float
  const std::vector<double>& values = surface->bounds().values();
  boundValues.insert(boundValues.end(), values.begin(), values.end());
}

◆ encodeSurface() [2/3]

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

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

Definition at line 79 of file SurfaceEncoding.cxx.

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

◆ encodeSurface() [3/3]

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

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

Warning

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

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

Definition at line 72 of file SurfaceEncoding.cxx.

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

◆ energyToActs()

double ActsTrk::energyToActs ( const double athenaE )

inlineconstexpr

Converts an energy scalar from Athena to Acts units.

Parameters

athenaE Energy value to convert

Definition at line 21 of file UnitConverters.h.

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

◆ energyToAthena()

double ActsTrk::energyToAthena ( const double actsE )

inlineconstexpr

Converts an energy scalar from Acts to Athena units.

Parameters

athenaE Energy value to convert

Definition at line 28 of file UnitConverters.h.

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

◆ getCalibrationContext()

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

inline

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

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

Parameters

ctx	EventContext to transform into a Context

Definition at line 15 of file CalibrationContext.h.

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

◆ getCellColumn() [1/2]

int ActsTrk::getCellColumn ( const StripClusteringTool::Cell & cell )

static

Definition at line 26 of file StripClusteringTool.cxx.

{
    return cell.index;
}

◆ getCellColumn() [2/2]

int ActsTrk::getCellColumn ( const typename PixelClusteringTool::Cell & cell )

inlinestatic

Definition at line 26 of file PixelClusteringTool.cxx.

26{ return cell.COL; }

◆ getCellRow()

int ActsTrk::getCellRow ( const typename PixelClusteringTool::Cell & cell )

inlinestatic

Definition at line 25 of file PixelClusteringTool.cxx.

25{ return cell.ROW; }

◆ getDepositedEnergy()

template<class T_Deposit>

float ActsTrk::getDepositedEnergy ( const T_Deposit & )

◆ getInTruthPropertyName()

template<class T_TruthEventCollection>

const char * ActsTrk::getInTruthPropertyName ( )

inline

◆ getRDOList()

template<class T>

auto ActsTrk::getRDOList ( const T & a )

Definition at line 109 of file MeasurementToTruthAssociationAlg.h.

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

◆ getSimDataDeposits()

template<class T_SimDataCollection, class T_SimDataIterator>

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

◆ getSurfaceGeometryIdOfMeasurement()

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

inline

Definition at line 13 of file SurfaceOfMeasurementUtil.h.

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

◆ getUncalibratedMeasurement()

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

inline

Definition at line 26 of file ATLASSourceLink.h.

                                                                                                                   {
      assert(source_link);
      return *source_link;
   }

◆ lengthToActs()

double ActsTrk::lengthToActs ( const double athenaL )

inlineconstexpr

Converts a length scalar from Acts to Athena units.

Parameters

athenaL Length value to convert

Definition at line 35 of file UnitConverters.h.

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

◆ lengthToAthena()

double ActsTrk::lengthToAthena ( const double actsL )

inlineconstexpr

Converts a length scalar from Acts to Athena units.

Parameters

athenaL Length value to convert

Definition at line 42 of file UnitConverters.h.

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

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

◆ localXFromSourceLink()

float ActsTrk::localXFromSourceLink ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 53 of file ATLASSourceLink.h.

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

◆ localYFromSourceLink()

float ActsTrk::localYFromSourceLink ( const ATLASUncalibSourceLink & source_link )

inline

Definition at line 60 of file ATLASSourceLink.h.

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

◆ makeATLASUncalibSourceLink() [1/4]

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

inline

Definition at line 49 of file ATLASSourceLink.h.

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

◆ makeATLASUncalibSourceLink() [2/4]

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

inline

Definition at line 36 of file ATLASSourceLink.h.

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

◆ makeATLASUncalibSourceLink() [3/4]

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

inline

Definition at line 43 of file ATLASSourceLink.h.

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

◆ makeATLASUncalibSourceLink() [4/4]

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

inline

Definition at line 30 of file ATLASSourceLink.h.

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

◆ makeDepositToTruthParticleMap()

template<class T_TruthEventCollection>

auto ActsTrk::makeDepositToTruthParticleMap ( const T_TruthEventCollection * truth_particle_links )

◆ makeDetectorElementKey()

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

inline

Definition at line 23 of file DetectorElementToActsGeometryIdMap.h.

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

◆ makeInterfaceContainer()

template<typename IFACE, typename AUX>

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

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

Definition at line 516 of file MultiTrajectory.h.

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

◆ operator<() [1/3]

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

inline

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

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

◆ operator<() [2/3]

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

inline

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

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

◆ operator<() [3/3]

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

inline

Comparison operators.

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

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

◆ operator<<()

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

inline

Definition at line 25 of file TrackToTruthAssociationAlg.cxx.

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

◆ prefixFromTrackContainerName()

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

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

Definition at line 20 of file TrackContainerHandlesHelper.cxx.

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

◆ printHeader()

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

static

Definition at line 118 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 226 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 ActsDetectorElement *
            acts_detector_element = dynamic_cast<const ActsDetectorElement *>(surface->associatedDetectorElement());
        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 213 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 202 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 178 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 189 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) << "";
    }
  }

◆ timeToActs()

double ActsTrk::timeToActs ( const double athenaT )

inlineconstexpr

Converts a time unit from Athena to Acts units.

Parameters

athenaT Time interval to convert

Definition at line 49 of file UnitConverters.h.

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

◆ timeToAthena()

double ActsTrk::timeToAthena ( const double actsT )

inlineconstexpr

Converts a time unit from Acts to Athena units.

Parameters

actsT Time interval to convert

Definition at line 56 of file UnitConverters.h.

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

◆ to_string()

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

inline

Definition at line 34 of file GeometryDefs.h.

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

◆ to_underlying()

template<typename T>

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

Definition at line 14 of file ActsInspectTruthContentAlg.cxx.

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

Variable Documentation

◆ DETELEMENT_HASH_MASK

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

constexpr

Definition at line 21 of file DetectorElementToActsGeometryIdMap.h.

◆ DETELEMENT_TYPE_SHIFT

unsigned int ActsTrk::DETELEMENT_TYPE_SHIFT = 28

constexpr

Definition at line 20 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 20 of file StripClusteringTool.cxx.

◆ oneStripSF

float ActsTrk::oneStripSF = 1.1025

constexpr

Definition at line 21 of file StripClusteringTool.cxx.

◆ s_toTesla

float ActsTrk::s_toTesla = 0.299785832

staticconstexpr

Definition at line 43 of file SiSpacePointsSeedMaker.h.

◆ TrackFindingValidationDebugHists

bool ActsTrk::TrackFindingValidationDebugHists = false

constexpr

Definition at line 41 of file TrackTruthMatchingBaseAlg.h.

◆ TrackFindingValidationDetailedStat

bool ActsTrk::TrackFindingValidationDetailedStat = true

constexpr

Definition at line 42 of file TrackTruthMatchingBaseAlg.h.

◆ TrackToTruthParticleAssociationDebugHists

bool ActsTrk::TrackToTruthParticleAssociationDebugHists = false

constexpr

Definition at line 42 of file TrackToTruthAssociationAlg.h.

◆ TruthParticleHitCountDebugHists

bool ActsTrk::TruthParticleHitCountDebugHists = false

constexpr

Definition at line 42 of file TruthParticleHitCountAlg.h.

◆ twoStripSF

float ActsTrk::twoStripSF = 0.0729

constexpr

Definition at line 22 of file StripClusteringTool.cxx.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ATLASSourceLink

◆ ATLASUncalibSourceLink

◆ AtlUncalibSourceLinkAccessor

◆ BoundTrackParametersContainer

◆ ConstCovariance

◆ ConstParameters

◆ Covariance

◆ DefaultTrackStateCreator

◆ DetectorElementKey

◆ IndexType

◆ MuonChamberSet

◆ MuonSectorSet

◆ MutablePersistentTrackBackend

◆ MutablePersistentTrackStateBackend

◆ MutableTrackBackend

◆ MutableTrackContainer

◆ MutableTrackStateBackend

◆ Parameters

◆ ParticleVector

◆ PersistentTrackBackend

◆ PersistentTrackContainerBase

◆ PersistentTrackStateBackend

◆ ProtoTrackCollection

◆ rdoListFunc_t

◆ ReturnedHintArr

◆ ReturnedTicketArr

◆ staticNodePtr

◆ StIdx

◆ StoredSurface

◆ SurfaceCacheSet

◆ surfacePtr

◆ TicketCounterArr

◆ TrackBackend

◆ TrackContainerBase

◆ TrackStateBackend

◆ TruthParticleHitCounts

Enumeration Type Documentation

◆ DetectorType

◆ NeighbourIndices

Function Documentation

◆ actsLevelVector()

◆ ActsMeasurementCheck()

◆ ActsTrackParameterCheck()

◆ athLevelVector()

◆ atlasSurfaceName()

◆ clusterAddCell() [1/2]

◆ clusterAddCell() [2/2]

◆ clusterReserve() [1/2]

◆ clusterReserve() [2/2]

◆ computePosition()

◆ convertDirFromActs()

◆ convertDirToActs()

◆ convertMomFromActs()

◆ convertMomToActs()

◆ convertPosFromActs()

◆ convertPosToActs()

◆ createDecoratorKeys()

◆ createDecorators()

◆ decodeSurface() [1/3]

◆ decodeSurface() [2/3]

◆ decodeSurface() [3/3]

◆ encodeSurface() [1/3]

◆ encodeSurface() [2/3]

◆ encodeSurface() [3/3]

◆ energyToActs()

◆ energyToAthena()

◆ getCalibrationContext()

◆ getCellColumn() [1/2]

◆ getCellColumn() [2/2]

◆ getCellRow()

◆ getDepositedEnergy()

◆ getInTruthPropertyName()