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	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	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
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	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	ActsVolumeIdToDetectorElementCollectionMap
struct	DetectorElementToActsGeometryIdMap
class	ExtrapolationTool
class	ActsVolumeIdToDetectorElementCollectionMappingAlg
class	CaloBlueprintNodeBuilder
	Builds the Calo Blueprint Node. 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
class	TrackingGeometrySvc
class	TrackingGeometryTool
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	IDetectorElementBase
	base class interface providing the bare minimal interface extension. More...
class	IDetectorElement
	Base class interface for the actual readout elements. More...
class	IExtrapolationTool
	Tool to extrapolate bound track parameters. 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	ITrackingGeometrySvc
	Interface class for the ATLAS service providing the ActsTrackingGeometry. More...
class	ITrackingGeometryTool
	Geometry helper tool extending the Tracking geometry service by the data dependency to fetch the geometry context from StoreGate. More...
class	IVolumePlacement
	ATLAS extension of the VolumePlacementBase interface. More...
class	TransformCacheDetEle
class	SurfaceCache
	: Helper class to connect the aligned transformations of each active sensor(layer) with the Acts::Surfaces. More...
class	TransformCacheBase
class	TransformCache
	Implementation used for the Detector elements. More...
class	VolumePlacement
	Implementation to make a (tracking) volume alignable. More...
class	CUDAClusterizationAlgProviderTool
class	DeviceClusterizationAlg
class	IDeviceClusterizationAlgProviderTool
class	JSONDeviceDetectorDescriptionProviderSvc
class	RDOtoTracccCellConverterAlg
class	TracccMeasurementConverterAlg
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	ActsInspectTruthContentAlg
class	EstimatedTrackParamsAnalysisAlg
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	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	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	SurfaceCacheSet = std::set<std::unique_ptr<SurfaceCache>, std::less<>>
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...

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

Header file to manage the common inlcudes.

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

ATLAS extension of the Acts::SurfacePlacementBase. 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.

In AthSimulation, the Acts core library is not available yet

forward declarations of the classes defined in the package

Typedef Documentation

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

SurfaceCacheSet

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

Definition at line 18 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/Defs.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};

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

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

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

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

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

operator<() [1/3]

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

inline

Definition at line 64 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 67 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 60 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

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

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 97 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 101 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 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->surfacePlacement());
        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) << "";
    }
  }

rotateParams()

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

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

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

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 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 21 of file StripClusteringTool.cxx.