Acts Namespace Reference

Acts includes to create all necessary definitions. More...

Namespaces
namespace	AxisJsonConverter
namespace	Ccl
namespace	Concepts
namespace	Cuda
namespace	detail
	These functions perform the transport of a covariance matrix using given Jacobians. The required data is provided by the stepper object with some additional data. Since this is a purely algebraic problem the calculations are identical for StraightLineStepper and EigenStepper. As a consequence the methods can be located in a separate file.
namespace	detail_lt
namespace	detail_tc
namespace	detail_vmt
namespace	detail_vtc
namespace	DetectorJsonConverter
namespace	DetectorVolumeJsonConverter
namespace	DetrayJsonHelper
namespace	EDM4hepUtil
namespace	EventDataView3DTest
namespace	Experimental
namespace	Geant4PhysicalVolumeSelectors
namespace	GridJsonConverter
namespace	GsfConstants
namespace	HashedStringLiteral
namespace	IndexedSurfacesJsonConverter
namespace	IntegrationTest
namespace	KalmanVertexTrackUpdater
namespace	KalmanVertexUpdater
namespace	Legacy
namespace	Logging
	debug output related helper classes and functions
namespace	MultiTrajectoryHelpers
namespace	MultiTrajectoryTraits
namespace	PhysicalConstants
namespace	PlanarHelper
	Helpers for planar surfaces that share the same maths.
namespace	podio_detail
namespace	PodioUtil
namespace	PortalJsonConverter
namespace	PrimitivesView3DTest
namespace	Python
namespace	SurfaceBoundsJsonConverter
namespace	SurfaceJsonConverter
namespace	SurfaceView3DTest
namespace	Svg
namespace	Sycl
namespace	Test
namespace	TrackingGeometryView3DTest
namespace	Transform3JsonConverter
namespace	UnitConstants
namespace	UnitLiterals
namespace	VectorHelpers
namespace	VolumeBoundsJsonConverter
namespace	VolumeView3DTest

Classes
class	GreedyAmbiguityResolution
exception	Direction
struct	ParticleData
struct	ProtoVolume
struct	ProtoDetector
class	CartesianSegmentation
	Segmentation Base class. More...
struct	DigitizationCell
	pair of ints for definition of a cell More...
struct	DigitizationStep
	DigitizationStep for further handling. More...
class	DigitizationModule
exception	DigitizationSourceLink
	Source link to connect digitization clusters back to truth information. More...
class	PlanarModuleCluster
class	PlanarModuleStepper
class	Segmentation
	Segmentation Base class. More...
struct	Neutral
	Charge and momentum interpretation for neutral particles. More...
struct	SinglyCharged
	Charge and momentum interpretation for particles with +-e charge. More...
class	NonNeutralCharge
class	AnyCharge
struct	FreeToBoundCorrection
	Free to bound transformation Correction configuration class. More...
class	GenericBoundTrackParameters
class	GenericCurvilinearTrackParameters
class	GenericFreeTrackParameters
class	GenericParticleHypothesis
	Particle hypothesis used in reconstruction. More...
class	Measurement
class	MultiComponentBoundTrackParameters
class	MultiComponentCurvilinearTrackParameters
struct	TrackStateTraits
class	MultiTrajectory
class	SinglyChargedParticleHypothesis
class	NeutralParticleHypothesis
class	NonNeutralChargedParticleHypothesis
class	ParticleHypothesis
exception	SourceLink
struct	SourceLinkAdapterIterator
class	SpacePointData
class	TrackContainer
struct	TrackAccessorBase
class	TrackProxy
class	TrackStateType
class	ConstTrackStateType
struct	IsReadOnlyMultiTrajectory< VectorMultiTrajectory >
exception	VectorMultiTrajectory
struct	IsReadOnlyMultiTrajectory< ConstVectorMultiTrajectory >
exception	ConstVectorMultiTrajectory
struct	IsReadOnlyTrackContainer< VectorTrackContainer >
exception	VectorTrackContainer
struct	IsReadOnlyTrackContainer< ConstVectorTrackContainer >
exception	ConstVectorTrackContainer
class	AbstractVolume
class	ApproachDescriptor
class	BoundarySurfaceT
class	ConeLayer
class	ConeVolumeBounds
class	CuboidVolumeBounds
class	CuboidVolumeBuilder
	This class builds a box detector with a configurable amount of surfaces in it. The idea is to allow a quick configuration of a detector for mostly unit test applications. Therefore this class does not demand to be a universal construction factory but a raw first draft of the idea of factory that may be extended in the future. More...
class	CutoutCylinderVolumeBounds
class	CylinderLayer
class	CylinderVolumeBounds
struct	VolumeConfig
	VolumeConfig struct to understand the layer config. More...
struct	WrappingConfig
	The WrappingSetup that is happening here. More...
class	CylinderVolumeBuilder
class	CylinderVolumeHelper
class	DetectorElementBase
class	DiscLayer
class	Extent
class	GenericApproachDescriptor
class	GenericCuboidVolumeBounds
class	GeometryHierarchyMap
class	GeometryIdentifier
struct	GeometryIdentifierHook
class	GeometryObject
class	ObjectSorterT
class	DistanceSorterT
	This will check on absolute distance. More...
class	GeometryObjectSorterT
class	GlueVolumesDescriptor
class	IConfinedTrackingVolumeBuilder
	This is an interface class for constructing TrackingVolumes whose are confined in a mother-TrackingVolume. More...
class	ILayerArrayCreator
class	ILayerBuilder
class	ITrackingGeometryBuilder
class	ITrackingVolumeArrayCreator
class	ITrackingVolumeBuilder
class	ITrackingVolumeHelper
class	KDTreeTrackingGeometryBuilder
class	Layer
class	LayerArrayCreator
class	LayerCreator
class	NavigationLayer
class	PassiveLayerBuilder
class	PlaneLayer
class	Polyhedron
struct	ProtoLayer
class	ProtoLayerHelper
class	SurfaceArrayCreator
struct	SurfaceBinningMatcher
class	TrackingGeometry
class	TrackingGeometryBuilder
class	TrackingVolume
class	TrackingVolumeArrayCreator
class	TrapezoidVolumeBounds
class	Volume
class	VolumeBounds
exception	ConstantBField
class	InterpolatedMagneticField
class	InterpolatedBFieldMap
	interpolate magnetic field value from field values on a given grid More...
class	MagneticFieldProvider
	Base class for all magnetic field providers. More...
exception	NullBField
	Null bfield which returns 0 always. More...
class	SolenoidBField
class	AccumulatedMaterialSlab
class	AccumulatedSurfaceMaterial
class	AccumulatedVolumeMaterial
class	BinnedSurfaceMaterial
class	HomogeneousSurfaceMaterial
class	HomogeneousVolumeMaterial
class	IMaterialDecorator
struct	MaterialMapper
	Struct for mapping global 3D positions to material values. More...
class	InterpolatedMaterialMap
	Interpolate material classification values from material values on a given grid. More...
class	ISurfaceMaterial
class	IVolumeMaterial
	Material associated with a Volume (homogeneous, binned, interpolated) More...
class	Material
struct	MaterialHit
	The information to be writtern out per hit surface. More...
struct	MaterialCollector
	A Material Collector struct. More...
class	ElementFraction
class	MaterialComposition
struct	InteractionVolume
	The Material interaction volume struct It acts as a switch between detctor and tracking volume as long as those co-exist alongside. More...
struct	MaterialInteraction
	The Material interaction struct It records the surface and the passed material This is only necessary recorded when configured. More...
struct	RecordedMaterial
class	MaterialSlab
class	ProtoSurfaceMaterial
	proxy to SurfaceMaterial hand over BinUtility More...
class	ProtoVolumeMaterial
	proxy to VolumeMaterial hand over BinUtility More...
struct	MaterialSurface
	selector for finding surface More...
struct	MaterialVolume
	selector for finding volume More...
class	SurfaceMaterialMapper
	SurfaceMaterialMapper. More...
class	VolumeMaterialMapper
	VolumeMaterialMapper. More...
class	AtlasStepper
	the AtlasStepper implementation for the More...
class	ConstrainedStep
struct	CovarianceCache
struct	DenseStepperPropagatorOptions
class	DirectNavigator
class	EigenStepper
	Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE: More...
struct	MaterialInteractor
struct	WeightedComponentReducerLoop
	Reducer struct for the Loop MultiEigenStepper which reduces the multicomponent state to simply by summing the weighted values. More...
struct	MaxMomentumReducerLoop
class	MultiEigenStepperLoop
	Stepper based on the EigenStepper, but handles Multi-Component Tracks (e.g., for the GSF). Internally, this only manages a vector of EigenStepper::States. This simplifies implementation, but has several drawbacks: More...
struct	MultiStepperSurfaceReached
	This. More...
struct	NavigationOptions
	struct for the Navigation options that are forwarded to the geometry More...
class	Navigator
struct	PropagatorResult
	Simple class holding result of propagation call. More...
struct	PropagatorPlainOptions
	Class holding the trivial options in propagator options. More...
struct	PropagatorOptions
	Options for propagate() call. More...
exception	Propagator
	Propagator for particles (optionally in a magnetic field) More...
class	RiddersPropagator
	This class performs the Ridders algorithm to estimate the propagation of the covariance to a certain point in space. More...
struct	TargetOptions
	TargetOptions struct for geometry interface. More...
struct	PathLimitReached
	This is the condition that the pathLimit has been reached. More...
struct	SurfaceReached
struct	EndOfWorldReached
struct	StepperExtensionList
	Container of extensions used in the stepper of the propagation. This struct allows a broadcast of function calls for each element in the list. The broadcasts occur for a certain function at each step in a specific order. The first function is an evaluater if an extension is or how many extensions are applicable for an upcoming step. The next functions called are the evaluations of the k_1 - k_4 or the RKN4 integration. The last function call in a step is the finalize() method. This method is an overloaded function (optionally propagates the covariance). Each method has the possibility to break the evaluation of a given step if an extension reports that something went wrong (e.g. a particle lost too much momentum during the step) More...
class	StraightLineStepper
	straight line stepper based on Surface intersection More...
struct	SurfaceSelector
	Simple struct to select surfaces. More...
struct	SurfaceHit
	The information to be writtern out per hit surface. More...
struct	SurfaceCollector
struct	VolumeSelector
	Simple struct to select volumes. More...
struct	VolumeHit
	The information to be writtern out per hit volume. More...
struct	VolumeCollector
class	BinFinder
class	BinnedSPGroupIterator
class	BinnedSPGroup
struct	TripletCandidate
	A description of a triplet candidate. More...
class	CandidatesForMiddleSp
struct	FTF_SP
class	TrigFTF_GNN_Node
class	TrigFTF_GNN_EtaBin
class	TrigFTF_GNN_DataStorage
class	TrigFTF_GNN_Edge
class	TrigInDetSiLayer
class	TrigFTF_GNN_Layer
class	TrigFTF_GNN_Geometry
class	IExperimentCuts
class	InternalSeed
class	InternalSpacePoint
struct	Neighbour
	A class that helps in processing the neighbours, given a collection of middle space points The idea here is that in the seeding we look for compatible b-m and m-t doublets. One of the requirements is that the bottom/top space point is at a suitable distance (in radius) w.r.t. the middle space point. We know however that the space points in each bin are sorted in radius. That means we can use this sorting in order to reduce the number of space point to consider when looking for compatible doublets. The idea is to keep track of first space point that is in the allowed bin, by storing its position using an iterator itr This helps us since the lower possible buondary is given by the first middle space point (its radius minus the mad deltaR defined by the user). The subsequent middle space point will have a higher radius. That means that there is no point in looking at neighbour space point before itr, since we know they will be out of range. More...
class	Seed
struct	SeedConfirmationRangeConfig
	contains parameters for seed confirmation More...
struct	SeedFilterState
class	SeedFilter
struct	SeedFilterConfig
class	SeedFinder
struct	SeedFinderConfig
struct	SeedFinderOptions
struct	GNN_TrigTracklet
class	SeedFinderFTF
struct	SeedFinderFTFConfig
class	SeedFinderOrthogonal
struct	SeedFinderOrthogonalConfig
struct	LinCircle
	A partial description of a circle in u-v space. More...
struct	SpacePointGridConfig
struct	SpacePointGridOptions
class	SpacePointGridCreator
class	SpacePointBuilder
struct	SpacePointBuilderConfig
struct	SpacePointBuilderOptions
struct	StripPairOptions
class	AnnulusBounds
	Class that implements a (potentially asymmetric) bounds with difference between surface bound center and surface coordinate center. More...
class	BoundaryCheck
class	ConeBounds
class	ConeSurface
class	ConvexPolygonBoundsBase
	base class for convex polygon bounds More...
class	ConvexPolygonBounds
class	ConvexPolygonBounds< PolygonDynamic >
class	CylinderBounds
class	CylinderSurface
class	DiamondBounds
class	DiscBounds
class	DiscTrapezoidBounds
class	EllipseBounds
class	InfiniteBounds
class	LineBounds
class	LineSurface
class	PerigeeSurface
class	PlanarBounds
class	PlaneSurface
class	RadialBounds
class	RectangleBounds
class	StrawSurface
class	Surface
	Abstract Base Class for tracking surfaces. More...
class	SurfaceArray
	Provides Surface binning in N dimensions. More...
class	SurfaceBounds
class	TrapezoidBounds
struct	CombinatorialKalmanFilterTipState
struct	CombinatorialKalmanFilterExtensions
	Extension struct which holds the delegates to customize the CKF behavior. More...
struct	CombinatorialKalmanFilterOptions
struct	CombinatorialKalmanFilterResult
class	CombinatorialKalmanFilter
struct	FasTrackConnection
class	FasTrackConnector
struct	MeasurementSelectorCuts
class	MeasurementSelector
	Measurement selection struct selecting those measurements compatible with the given track parameter against provided criteria on one surface. More...
class	RoiDescriptor
class	TrackSelector
struct	BetheHeitlerApproxSingleCmp
class	AtlasBetheHeitlerApprox
class	GainMatrixSmoother
class	GainMatrixUpdater
	Kalman update step using the gain matrix formalism. More...
struct	GaussianSumFitter
struct	GsfComponent
struct	GsfExtensions
	The extensions needed for the GSF. More...
struct	GsfOptions
struct	KalmanFitterExtensions
	Extension struct which holds delegates to customise the KF behavior. More...
struct	KalmanFitterOptions
struct	KalmanFitterResult
class	KalmanFitter
struct	ExpSafeLimit
struct	ExpSafeLimit< double >
struct	ExpSafeLimit< float >
class	AnnealingUtility
	Implements a deterministic thermodynamic annealing scheme Ref. (1): CERN-THESIS-2010-027. More...
class	AnyBaseAll
class	AnyBase
	Small opaque cache type which uses small buffer optimization. More...
class	BinnedArray
class	BinnedArrayXD
class	BinningData
class	BinUtility
class	AxisAlignedBoundingBox
class	Delegate< R(Args...), H, O >
class	OwningDelegate< R(Args...), H >
	Alias for an owning delegate. More...
class	ContextType
class	FiniteStateMachine
class	Frustum
class	IAxis
struct	Identity
	Function object which maps a value to itself by perfect forwarding This is a backport of C++20's std::identity. More...
struct	Intersection
class	ObjectIntersection
	class extensions to return also the object and a representation More...
class	ObjectMultiIntersection
	class extensions to return also the object and a representation More...
class	KDTree
	A general k-d tree with fast range search. More...
class	Logger
	class for printing debug output More...
class	MultiIndex
class	Range1D
	A one-dimensional range between two points. More...
class	RangeXD
	An orthogonal range in an arbitrary number of dimensions. More...
class	Ray
class	Result
class	Result< void, E >
struct	SpacePointParameters
	Storage container for variables related to the calculation of space points. More...
class	SpacePointUtility
class	AssertionFailureException
	Exception type for assertion failures This class captures the information available to the throw_assert macro. More...
class	AdaptiveGridDensityVertexFinder
	Vertex finder that makes use of a track density grid. Each single track is modelled as a 2-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density vector) are superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate. Unlike the GridDensityVertexFinder, this seeder implements an adaptive version where the density grid grows bigger with added tracks. More...
class	AdaptiveGridTrackDensity
	Implements a 1D (no time seeding) / 2D (time seeding) grid that is filled with track densities. Each track is modelled by a 2D / 3D Gaussian distribution in the d0-z0 / d0-z0-t0 plane, which is evaluated at d0=0. Therefore, each track effectively lives in 1D / 2D. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density. Unlike in the GaussianGridTrackDensity, the overall density map grows adaptively when tracks densities are added to the grid. More...
class	AdaptiveMultiVertexFinder
	Implements an iterative vertex finder. More...
class	AdaptiveMultiVertexFitter
	Implements an adaptive multi-vertex fitter as described in detail in Section 5.3.5 in: Ref. (1): CERN-THESIS-2010-027, Author: Piacquadio, Giacinto: Identification of b-jets and investigation of the discovery potential of a Higgs boson in the WH−−>lvbb¯ channel with the ATLAS experiment More...
struct	VertexInfo
	Helper struct for storing vertex related information. More...
class	DummyVertexFitter
	Dummy vertex fitter class, only to be used for ensuring interfaces where a vertex fitter type is required but no fitter is actually needed. More...
class	FsmwMode1dFinder
class	FullBilloirVertexFitter
	Vertex fitter class implementing the Billoir vertex fitter. More...
class	GaussianGridTrackDensity
	Implements a 1-dim density grid to be filled with track Gaussian distributions. Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density. More...
class	GaussianTrackDensity
	Class to model tracks as 2D density functions based on their d0 and z0 perigee parameters (mean value) and covariance matrices (determining the width of the function) More...
class	GridDensityVertexFinder
	Vertex finder that makes use of a track density grid. Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density grid) a superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate. More...
class	HelicalTrackLinearizer
struct	ImpactParametersAndSigma
class	ImpactPointEstimator
	Estimator for impact point calculations A description of the underlying mathematics can be found here: https://github.com/acts-project/acts/pull/2506 TODO: Upload reference at a better place. More...
class	IterativeVertexFinder
	Implements an iterative vertex finder. More...
class	LinearizedTrack
class	NumericalTrackLinearizer
class	SingleSeedVertexFinder
	Implements the vertex finder based on the track seeds 0. Assumes there is only 1 vertex and that it has a high multiplicity. More...
class	TrackAtVertex
	Defines a track at vertex object. More...
class	TrackDensityVertexFinder
	Finds a vertex seed based on the maximum of a track density function. Each track is modelled as a 2d density function around its d0/z0 perigee parameter values. The z seed position is then found as the position of the maximum of all summed track density functions. More...
class	Vertex
	Class for storing vertex objects. More...
struct	VertexingOptions
	Vertex Finder Options. More...
class	ZScanVertexFinder
	Implements a vertex finder based on the mode of z0 values: More...
struct	EventDataView3D
struct	GeometryView3D
class	IVisualization3D
class	ObjVisualization3D
class	PlyVisualization3D
	Helper to write out PlyVisualization3D visualization format. More...
struct	ViewConfig
	Struct to concentrate all visualization configurations in order to harmonize visualization interfaces. More...
class	MappingMaterialDecorator
	Material decorator using a map as input. More...
class	MaterialWiper
struct	AutodiffExtensionWrapper
	Default RKN4 evaluator for autodiff. More...
class	SeedFinder< external_spacepoint_t, Acts::Cuda >
class	CpuMatrix
class	CpuScalar
class	CpuVector
class	DD4hepDetectorElement
	DetectorElement class implementation for DD4hep geometry. More...
class	DD4hepDetectorSurfaceFactory
class	DD4hepLayerBuilder
	build layers of one cylinder-endcap setup from DD4hep input More...
class	DD4hepVolumeBuilder
	build confined TrackingVolumes of one cylinder setup from DD4hep input. More...
exception	BoostTrackBuilding
exception	CugraphTrackBuilding
struct	ExaTrkXTiming
class	ExaTrkXHook
class	ExaTrkXPipeline
struct	ExaTrkXTime
	Collection of timing information of the Exa.TrkX algorithm. More...
class	ExaTrkXTimer
exception	OnnxEdgeClassifier
exception	OnnxMetricLearning
class	GraphConstructionBase
class	EdgeClassificationBase
class	TrackBuildingBase
exception	TorchEdgeClassifier
exception	TorchMetricLearning
class	TorchTruthGraphMetricsHook
class	FpeMonitor
struct	Geant4AlgebraConverter
struct	Geant4ShapeConverter
struct	Geant4PhysicalVolumeConverter
struct	Geant4MaterialConverter
struct	Geant4VolumeConverter
class	Geant4DetectorElement
class	Geant4DetectorSurfaceFactory
class	IGeant4PhysicalVolumeSelector
	Interface class for selectors from physical volumes. More...
class	IdentifiedDetectorElement
	The identified detector element. More...
class	GeometryHierarchyMapJsonConverter
struct	missing_specialization
struct	jsonKey
	store in a single place the different key used for the material mapping More...
class	ITrackingGeometryJsonDecorator
	helper class to add extra information to surface or volume json objects More...
class	IVolumeMaterialJsonDecorator
	helper class to add extra information to surface or volume json objects More...
class	JsonMaterialDecorator
	Material decorator from Json format. More...
class	MaterialMapJsonConverter
	read the material from Json More...
class	AmbiguityTrackClassifier
	Onnx model implementation for track scoring and selection. More...
class	MLTrackClassifier
class	OnnxRuntimeBase
struct	IsReadOnlyTrackContainer< MutablePodioTrackContainer >
struct	IsReadOnlyTrackContainer< ConstPodioTrackContainer >
class	PodioTrackContainerBase
class	MutablePodioTrackContainer
class	ConstPodioTrackContainer
class	PodioTrackStateContainerBase
struct	IsReadOnlyMultiTrajectory< ConstPodioTrackStateContainer >
exception	ConstPodioTrackStateContainer
struct	IsReadOnlyMultiTrajectory< MutablePodioTrackStateContainer >
exception	MutablePodioTrackStateContainer
class	ITGeoDetectorElementSplitter
	ITGeoElementSplitter. More...
class	ITGeoIdentifierProvider
	ITGeoIdentierProvider. More...
class	TGeoCylinderDiscSplitter
	TGeoCylinderDiscSplitter. More...
class	TGeoDetectorElement
class	TGeoLayerBuilder
struct	TGeoMaterialConverter
struct	TGeoParser
	TGeoParser is a helper struct that walks recursively through a TGeometry and selects by string comparison the TGeoNodes that match the criteria. More...
struct	TGeoPrimitivesHelper
struct	TGeoSurfaceConverter
	Helper struct to convert TGeoShapes into Surface or Volume Bounds. More...
class	LayerStub
class	TestAxis
class	MultiGrid1D
class	MultiGrid2D
class	ATLASBottomBinFinder
class	ATLASCuts
class	ATLASTopBinFinder
class	CovarianceTool
class	SurfaceBoundsStub
	Class to implement pure virtual method of SurfaceBounds for testing only. More...
class	SurfaceStub
	Surface derived class stub. More...
class	MockTrack
	Mock track object with minimal methods implemented for compilation. More...

Typedefs
using	ActsScalar = double
template<unsigned int kSize>
using	ActsVector = Eigen::Matrix< ActsScalar, kSize, 1 >
template<unsigned int kRows, unsigned int kCols>
using	ActsMatrix = Eigen::Matrix< ActsScalar, kRows, kCols >
template<unsigned int kSize>
using	ActsSquareMatrix = Eigen::Matrix< ActsScalar, kSize, kSize >
using	ActsDynamicVector = Eigen::Matrix< ActsScalar, Eigen::Dynamic, 1 >
using	ActsDynamicMatrix = Eigen::Matrix< ActsScalar, Eigen::Dynamic, Eigen::Dynamic >
using	Vector2 = ActsVector< 2 >
using	Vector3 = ActsVector< 3 >
using	Vector4 = ActsVector< 4 >
using	SquareMatrix2 = ActsSquareMatrix< 2 >
using	SquareMatrix3 = ActsSquareMatrix< 3 >
using	SquareMatrix4 = ActsSquareMatrix< 4 >
using	Translation2 = Eigen::Translation< ActsScalar, 2 >
using	Translation3 = Eigen::Translation< ActsScalar, 3 >
using	RotationMatrix2 = ActsMatrix< 2, 2 >
using	RotationMatrix3 = ActsMatrix< 3, 3 >
using	AngleAxis3 = Eigen::AngleAxis< ActsScalar >
using	Transform2 = Eigen::Transform< ActsScalar, 2, Eigen::AffineCompact >
using	Transform3 = Eigen::Transform< ActsScalar, 3, Eigen::Affine >
using	AlignmentVector = ActsVector< eAlignmentSize >
using	AlignmentRowVector = ActsMatrix< 1, eAlignmentSize >
using	AlignmentMatrix = ActsMatrix< eAlignmentSize, eAlignmentSize >
using	AlignmentToPositionMatrix = ActsMatrix< 3, eAlignmentSize >
using	AlignmentToBoundMatrix = ActsMatrix< eBoundSize, eAlignmentSize >
using	AlignmentToPathMatrix = ActsMatrix< 1, eAlignmentSize >
using	BoundVector = ActsVector< eBoundSize >
using	BoundMatrix = ActsMatrix< eBoundSize, eBoundSize >
using	BoundSquareMatrix = ActsSquareMatrix< eBoundSize >
using	BoundToFreeMatrix = ActsMatrix< eFreeSize, eBoundSize >
using	FreeVector = ActsVector< eFreeSize >
using	FreeMatrix = ActsMatrix< eFreeSize, eFreeSize >
using	FreeSquareMatrix = ActsSquareMatrix< eFreeSize >
using	FreeToBoundMatrix = ActsMatrix< eBoundSize, eFreeSize >
using	FreeToPathMatrix = ActsMatrix< 1, eFreeSize >
using	SurfacePtr = std::shared_ptr< const Surface >
using	SurfacePtrVector = std::vector< SurfacePtr >
template<typename indices_t >
using	VariantMeasurement = typename detail::VariantMeasurementGenerator< indices_t, detail::kParametersSize< indices_t >>::Type
using	BoundVariantMeasurement = VariantMeasurement< BoundIndices >
using	FreeVariantMeasurement = VariantMeasurement< FreeIndices >
using	SourceLinkSurfaceAccessor = Delegate< const Surface *(const SourceLink &)>
	Delegate to unpack the surface associated with a source link.
template<typename T >
using	TrackAccessor = TrackAccessorBase< T, false >
template<typename T >
using	ConstTrackAccessor = TrackAccessorBase< T, true >
using	SinglyChargedBoundTrackParameters = GenericBoundTrackParameters< SinglyChargedParticleHypothesis >
using	SinglyChargedCurvilinearTrackParameters = GenericCurvilinearTrackParameters< SinglyChargedParticleHypothesis >
using	SinglyChargedFreeTrackParameters = GenericFreeTrackParameters< SinglyChargedParticleHypothesis >
using	NeutralBoundTrackParameters = GenericBoundTrackParameters< NeutralParticleHypothesis >
using	NeutralCurvilinearTrackParameters = GenericCurvilinearTrackParameters< NeutralParticleHypothesis >
using	NeutralFreeTrackParameters = GenericFreeTrackParameters< NeutralParticleHypothesis >
using	BoundTrackParameters = GenericBoundTrackParameters< ParticleHypothesis >
	BoundTrackParameters can hold any kind of charge.
using	CurvilinearTrackParameters = GenericCurvilinearTrackParameters< ParticleHypothesis >
	CurvilinearTrackParameters can hold any kind of charge.
using	FreeTrackParameters = GenericFreeTrackParameters< ParticleHypothesis >
	FreeTrackParameters can hold any kind of charge.
using	TrackIndexType = std::uint32_t
using	ProjectorBitset = uint64_t
using	BoundarySurfacePtr = std::shared_ptr< const BoundarySurfaceT< AbstractVolume >>
using	VolumeBoundsPtr = std::shared_ptr< const VolumeBounds >
using	Envelope = std::array< ActsScalar, 2 >
using	ExtentEnvelope = std::array< Envelope, binValues >
using	GeometryContext = ContextType
	This is the central definition of the Acts payload object regarding detector geometry status (e.g. alignment)
using	TrackingVolumePtr = std::shared_ptr< const TrackingVolume >
	A std::shared_ptr to a tracking volume.
using	TrackingVolumeArray = BinnedArray< TrackingVolumePtr >
	A BinnedArray of a std::shared_tr to a TrackingVolume.
using	MutableTrackingVolumePtr = std::shared_ptr< TrackingVolume >
using	MutableTrackingVolumeVector = std::vector< MutableTrackingVolumePtr >
using	LayerPtr = std::shared_ptr< const Layer >
	A std::shared_ptr to a Layer.
using	LayerArray = BinnedArray< LayerPtr >
	A BinnedArray to a std::shared_ptr of a layer.
using	LayerVector = std::vector< LayerPtr >
	A vector of std::shared_ptr to layers.
using	TrackingVolumeVector = std::vector< TrackingVolumePtr >
	A std::vector of a std::shared_ptr to a TrackingVolume.
using	SurfaceIntersection = ObjectIntersection< Surface >
	Typedef of the surface intersection.
using	MutableLayerPtr = std::shared_ptr< Layer >
using	NextLayers = std::pair< const Layer *, const Layer * >
using	SurfaceMatcher = std::function< bool(const GeometryContext &gctx, BinningValue, const Surface *, const Surface *)>
using	SurfaceVector = std::vector< const Surface * >
using	SurfaceMatrix = std::vector< SurfaceVector >
using	V3Vector = std::vector< Vector3 >
using	V3Matrix = std::vector< V3Vector >
using	AxisScalar = Vector3::Scalar
using	TrackingVolumeBoundaryPtr = std::shared_ptr< const BoundarySurfaceT< TrackingVolume >>
using	TrackingVolumeBoundaries = std::vector< TrackingVolumeBoundaryPtr >
using	LayerIntersection = ObjectIntersection< Layer, Surface >
	Intersection with Layer.
using	LayerMultiIntersection = ObjectMultiIntersection< Layer, Surface >
	Multi-intersection with Layer.
using	BoundarySurface = BoundarySurfaceT< TrackingVolume >
	BoundarySurface of a volume.
using	BoundaryIntersection = ObjectIntersection< BoundarySurface, Surface >
	Intersection with a BoundarySurface.
using	BoundaryMultiIntersection = ObjectMultiIntersection< BoundarySurface, Surface >
	Multi-intersection with a BoundarySurface.
using	TrackingVolumeOrderPosition = std::pair< TrackingVolumePtr, Vector3 >
using	OrientedSurface = std::pair< std::shared_ptr< Surface >, Direction >
using	OrientedSurfaces = std::vector< OrientedSurface >
using	MagneticFieldContext = ContextType
	This is the central definition of the Acts payload object regarding magnetic field status.
using	EAxis = Acts::detail::EquidistantAxis
using	Grid2D = Acts::detail::Grid< Acts::AccumulatedVolumeMaterial, EAxis, EAxis >
using	Grid3D = Acts::detail::Grid< Acts::AccumulatedVolumeMaterial, EAxis, EAxis, EAxis >
using	MaterialGrid2D = Acts::detail::Grid< Acts::Material::ParametersVector, EAxis, EAxis >
using	MaterialGrid3D = Acts::detail::Grid< Acts::Material::ParametersVector, EAxis, EAxis, EAxis >
using	MaterialGridAxisData = std::tuple< double, double, size_t >
using	RecordedMaterialTrack = std::pair< std::pair< Acts::Vector3, Acts::Vector3 >, RecordedMaterial >
using	MaterialSlabVector = std::vector< MaterialSlab >
using	MaterialSlabMatrix = std::vector< MaterialSlabVector >
using	RecordedMaterialVolumePoint = std::vector< std::pair< Acts::MaterialSlab, std::vector< Acts::Vector3 >>>
	list of point used in the mapping of a volume
using	VariantCovariance = std::variant< BoundSquareMatrix, FreeSquareMatrix >
using	VariantTransportJacobian = std::variant< BoundMatrix, BoundToFreeMatrix, FreeToBoundMatrix, FreeMatrix >
using	DefaultExtension = detail::GenericDefaultExtension< double >
	A typedef for the default GenericDefaultExtension with double.
using	DenseEnvironmentExtension = detail::GenericDenseEnvironmentExtension< double >
	A typedef for the default GenericDenseEnvironmentExtension with double.
template<typename external_spacepoint_t >
using	SpacePointGrid = detail::Grid< std::vector< std::unique_ptr< InternalSpacePoint< external_spacepoint_t >>>, detail::Axis< detail::AxisType::Equidistant, detail::AxisBoundaryType::Closed >, detail::Axis< detail::AxisType::Variable, detail::AxisBoundaryType::Bound >>
using	SurfaceMultiIntersection = ObjectMultiIntersection< Surface >
	Typedef of the surface multi-intersection.
template<typename source_link_iterator_t >
using	SourceLinkAccessorDelegate = Delegate< std::pair< source_link_iterator_t, source_link_iterator_t >(const Surface &)>
using	Any = AnyBase< sizeof(void *)>
using	CalibrationContext = std::any
	This is the central definition of the Acts payload object regarding detector calibration.
using	HashedString = std::uint32_t
using	Intersection2D = Intersection< 2 >
using	Intersection3D = Intersection< 3 >
using	MultiIntersection3D = boost::container::static_vector< Intersection3D, s_maximumNumberOfIntersections >
using	Ray3D = Ray< ActsScalar, 3 >
using	ColorRGB = std::array< int, 3 >
using	SurfaceMaterialMap = std::map< GeometryIdentifier, std::shared_ptr< const ISurfaceMaterial >>
using	VolumeMaterialMap = std::map< GeometryIdentifier, std::shared_ptr< const IVolumeMaterial >>
using	DetectorMaterialMaps = std::pair< SurfaceMaterialMap, VolumeMaterialMap >
using	RecordedMaterial = MaterialInteractor::result_type
using	volumeMaterialPointer = const Acts::IVolumeMaterial *
using	surfaceMaterialPointer = const Acts::ISurfaceMaterial *
using	SurfaceAndMaterialWithContext = std::tuple< std::shared_ptr< const Acts::Surface >, std::shared_ptr< const Acts::ISurfaceMaterial >, Acts::GeometryContext >
using	TrackingVolumeAndMaterial = std::pair< const Acts::TrackingVolume *, std::shared_ptr< const Acts::IVolumeMaterial >>
using	TrackingVolumePointer = const Acts::TrackingVolume *
using	NetworkBatchInput = Eigen::Array< float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >
using	IdentifiedPolyhedron = std::tuple< std::string, bool, Polyhedron >

Enumerations
enum	AlignmentIndices : unsigned int {   eAlignmentCenter0 = 0u, eAlignmentCenter1 = eAlignmentCenter0 + 1u, eAlignmentCenter2 = eAlignmentCenter0 + 2u, eAlignmentRotation0 = 3u,   eAlignmentRotation1 = eAlignmentRotation0 + 1u, eAlignmentRotation2 = eAlignmentRotation0 + 2u, eAlignmentSize }
enum	MaterialUpdateStage : int
enum	NoiseUpdateMode : int { removeNoise = -1, addNoise = 1 }
enum	CoordinateIndices : unsigned int {   ePos0 = 0, ePos1 = 1, ePos2 = 2, eTime = 3,   eMom0 = ePos0, eMom1 = ePos1, eMom2 = ePos2, eEnergy = eTime,   eX = ePos0, eY = ePos1, eZ = ePos2 }
enum	PdgParticle : int32_t {   eInvalid = 0, eElectron = 11, eAntiElectron = -eElectron, ePositron = -eElectron,   eMuon = 13, eAntiMuon = -eMuon, eTau = 15, eAntiTau = -eTau,   eGamma = 22, ePionZero = 111, ePionPlus = 211, ePionMinus = -ePionPlus,   eNeutron = 2112, eAntiNeutron = -eNeutron, eProton = 2212, eAntiProton = -eProton,   eLead = 1000822080 }
	Symbolic values for commonly used PDG particle numbers. More...
enum	BoundIndices : unsigned int {   eBoundLoc0 = 0, eBoundLoc1 = 1, eBoundPhi = 2, eBoundTheta = 3,   eBoundQOverP = 4, eBoundTime = 5, eBoundSize }
enum	FreeIndices : unsigned int {   eFreePos0 = 0u, eFreePos1 = eFreePos0 + 1u, eFreePos2 = eFreePos0 + 2u, eFreeTime = 3u,   eFreeDir0 = 4u, eFreeDir1 = eFreeDir0 + 1u, eFreeDir2 = eFreeDir0 + 2u, eFreeQOverP = 7u,   eFreeSize }
enum	TrackStatePropMask : std::uint8_t
enum	TrackStateFlag {   MeasurementFlag = 0, ParameterFlag = 1, OutlierFlag = 2, HoleFlag = 3,   MaterialFlag = 4, SharedHitFlag = 5, NumTrackStateFlags = 6 }
enum	BoundarySurfaceFace {   negativeFaceXY = 0, positiveFaceXY = 1, negativeFaceYZ = 2, positiveFaceYZ = 3,   negativeFaceZX = 4, positiveFaceZX = 5, cylinderCover = 2, tubeInnerCover = 3,   tubeOuterCover = 2, tubeSectorNegativePhi = 4, tubeSectorPositivePhi = 5, tubeSectorInnerCover = 3,   tubeSectorOuterCover = 2, trapezoidFaceAlpha = 2, trapezoidFaceBeta = 3, index0 = 0,   index1 = 1, index2 = 2, index3 = 3, index4 = 4,   index5 = 5, index6 = 6, index7 = 7, index8 = 8,   index9 = 9, index10 = 10, index11 = 11, undefinedFace = 99 }
enum	WrappingCondition {   Undefined = 0, Attaching = 1, Inserting = 2, Wrapping = 3,   CentralInserting = 4, CentralWrapping = 5, NoWrapping = 6 }
enum	LayerType { navigation = -1, passive = 0, active = 1 }
enum	MagneticFieldError
enum	MappingType { PreMapping = -1, Default = 0, PostMapping = 1, Sensor = 2 }
	This enum describes the type of surface material mapping. More...
enum	EigenStepperError
enum	MultiStepperError
enum	PropagatorError
enum	SpacePointCandidateType : short
enum	DetectorMeasurementInfo : short
enum	SurfaceError
enum	CombinatorialKalmanFilterTargetSurfaceStrategy
enum	CombinatorialKalmanFilterError
enum	GsfError
enum	KalmanFitterTargetSurfaceStrategy
enum	KalmanFitterError
enum	BinningType { equidistant, arbitrary }
enum	BinningOption { open, closed }
	flag for open/closed bins More...
enum	BinningValue : int {   binX = 0, binY = 1, binZ = 2, binR = 3,   binPhi = 4, binRPhi = 5, binH = 6, binEta = 7,   binMag = 8, binValues = 9 }
	how to take the global / local position More...
enum	DelegateType
	Ownership enum for Delegate. More...
enum	MixtureReductionMethod
enum	IntersectionStatus : int
	Status enum. More...
enum	LinIndices : unsigned int {   eLinPos0 = 0u, eLinPos1 = eLinPos0 + 1u, eLinPos2 = eLinPos0 + 2u, eLinTime = 3u,   eLinPhi = 4u, eLinTheta = eLinPhi + 1u, eLinQOverP = 6u, eLinSize = 7u,   eLinPosSize = 4u, eLinMomSize = 3u }
enum	VertexingError
enum	FpeType : uint32_t

Functions
std::ostream &	operator<< (std::ostream &os, MaterialUpdateStage matUpdate)
std::ostream &	operator<< (std::ostream &os, Direction dir)
constexpr int	operator* (Direction dir, int value)
constexpr float	operator* (Direction dir, float value)
constexpr double	operator* (Direction dir, double value)
Acts::Vector3	operator* (Direction dir, const Acts::Vector3 &value)
constexpr int	operator* (int value, Direction dir)
constexpr float	operator* (float value, Direction dir)
constexpr double	operator* (double value, Direction dir)
Acts::Vector3	operator* (const Acts::Vector3 &value, Direction dir)
constexpr int	operator*= (int &value, Direction dir)
constexpr float	operator*= (float &value, Direction dir)
constexpr double	operator*= (double &value, Direction dir)
Acts::Vector3 &	operator*= (Acts::Vector3 &value, Direction dir)
std::optional< float >	findCharge (PdgParticle pdg)
std::optional< float >	findMass (PdgParticle pdg)
std::optional< std::string_view >	findName (PdgParticle pdg)
std::optional< ParticleData >	findParticleData (PdgParticle pdg)
std::ostream &	operator<< (std::ostream &os, PdgParticle pdg)
	Print PDG particle numbers with a descriptive name.
std::optional< std::string_view >	pdgToShortAbsString (PdgParticle pdg)
static constexpr PdgParticle	makeAbsolutePdgParticle (PdgParticle pdg)
	Convert an anti-particle to its particle and leave particles as-is.
bool	operator== (const DigitizationSourceLink &lhs, const DigitizationSourceLink &rhs)
bool	operator!= (const DigitizationSourceLink &lhs, const DigitizationSourceLink &rhs)
	ACTS_STATIC_CHECK_CONCEPT (ChargeConcept, Neutral)
	ACTS_STATIC_CHECK_CONCEPT (ChargeConcept, SinglyCharged)
	ACTS_STATIC_CHECK_CONCEPT (ChargeConcept, NonNeutralCharge)
	ACTS_STATIC_CHECK_CONCEPT (ChargeConcept, AnyCharge)
template<typename parameters_t , typename covariance_t , typename indices_t , typename... tail_indices_t>
auto	makeMeasurement (SourceLink source, const Eigen::MatrixBase< parameters_t > &params, const Eigen::MatrixBase< covariance_t > &cov, indices_t index0, tail_indices_t...tailIndices) -> Measurement< indices_t, 1u+sizeof...(tail_indices_t)>
template<typename indices_t >
std::ostream &	operator<< (std::ostream &os, const VariantMeasurement< indices_t > &vm)
template<typename L , typename A , typename B >
auto	visit_measurement (A &&param, B &&cov, size_t dim, L &&lambda)
template<typename L >
auto	visit_measurement (size_t dim, L &&lambda)
template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >
	TrackContainer (track_container_t &container, traj_t &traj) -> TrackContainer< track_container_t, traj_t, detail::RefHolder >
template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >
	TrackContainer (const track_container_t &container, const traj_t &traj) -> TrackContainer< track_container_t, traj_t, detail::ConstRefHolder >
template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >
	TrackContainer (track_container_t &&container, traj_t &&traj) -> TrackContainer< track_container_t, traj_t, detail::ValueHolder >
template<typename track_container_t , typename track_state_container_t , template< typename > class holder_t>
void	calculateTrackQuantities (Acts::TrackProxy< track_container_t, track_state_container_t, holder_t, false > track)
std::ostream &	operator<< (std::ostream &os, TrackStatePropMask mask)
	ACTS_STATIC_CHECK_CONCEPT (MutableMultiTrajectoryBackend, VectorMultiTrajectory)
	ACTS_STATIC_CHECK_CONCEPT (ConstMultiTrajectoryBackend, ConstVectorMultiTrajectory)
	ACTS_STATIC_CHECK_CONCEPT (TrackContainerBackend, VectorTrackContainer)
	ACTS_STATIC_CHECK_CONCEPT (ConstTrackContainerBackend, ConstVectorTrackContainer)
std::ostream &	operator<< (std::ostream &os, BoundarySurfaceFace &face)
std::ostream &	operator<< (std::ostream &sl, const Extent &rhs)
	Overload of << operator for std::ostream for debug output.
std::ostream &	operator<< (std::ostream &os, GeometryIdentifier id)
std::ostream &	operator<< (std::ostream &sl, const GlueVolumesDescriptor &gvd)
std::ostream &	operator<< (std::ostream &sl, const Volume &vol)
std::ostream &	operator<< (std::ostream &sl, const VolumeBounds &vb)
	Overload of << operator for std::ostream for debug output.
bool	operator== (const VolumeBounds &lhs, const VolumeBounds &rhs)
Acts::InterpolatedBFieldMap < Acts::detail::Grid < Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	fieldMapRZ (const std::function< size_t(std::array< size_t, 2 > binsRZ, std::array< size_t, 2 > nBinsRZ)> &localToGlobalBin, std::vector< double > rPos, std::vector< double > zPos, std::vector< Acts::Vector2 > bField, double lengthUnit=UnitConstants::mm, double BFieldUnit=UnitConstants::T, bool firstQuadrant=false)
Acts::InterpolatedBFieldMap < Acts::detail::Grid < Acts::Vector3, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	fieldMapXYZ (const std::function< size_t(std::array< size_t, 3 > binsXYZ, std::array< size_t, 3 > nBinsXYZ)> &localToGlobalBin, std::vector< double > xPos, std::vector< double > yPos, std::vector< double > zPos, std::vector< Acts::Vector3 > bField, double lengthUnit=UnitConstants::mm, double BFieldUnit=UnitConstants::T, bool firstOctant=false)
Acts::InterpolatedBFieldMap < Acts::detail::Grid < Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	solenoidFieldMap (std::pair< double, double > rlim, std::pair< double, double > zlim, std::pair< size_t, size_t > nbins, const SolenoidBField &field)
std::error_code	make_error_code (Acts::MagneticFieldError e)
float	computeEnergyLossBethe (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	deriveEnergyLossBetheQOverP (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	computeEnergyLossLandau (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	deriveEnergyLossLandauQOverP (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	computeEnergyLossLandauSigma (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	computeEnergyLossLandauFwhm (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	computeEnergyLossLandauSigmaQOverP (const MaterialSlab &slab, float m, float qOverP, float absQ)
float	computeEnergyLossRadiative (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	deriveEnergyLossRadiativeQOverP (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	computeEnergyLossMean (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	deriveEnergyLossMeanQOverP (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	computeEnergyLossMode (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	deriveEnergyLossModeQOverP (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
float	computeMultipleScatteringTheta0 (const MaterialSlab &slab, PdgParticle absPdg, float m, float qOverP, float absQ)
std::ostream &	operator<< (std::ostream &os, const Material &material)
Grid2D	createGrid (MaterialGridAxisData gridAxis1, MaterialGridAxisData gridAxis2)
	Helper method that creates the cache grid for the mapping. This grid allows the collection of material at a the anchor points.
Grid3D	createGrid (MaterialGridAxisData gridAxis1, MaterialGridAxisData gridAxis2, MaterialGridAxisData gridAxis3)
	Helper method that creates the cache grid for the mapping. This grid allows the collection of material at a the anchor points.
std::function< double(Acts::Vector3)>	globalToLocalFromBin (Acts::BinningValue &type)
	return a function that return the coordinate corresponding to type of bin
Grid2D	createGrid2D (const BinUtility &bins, std::function< Acts::Vector2(Acts::Vector3)> &transfoGlobalToLocal)
	Create a 2DGrid using a BinUtility. Also determine the corresponding global to local transform and grid mapping function.
Grid3D	createGrid3D (const BinUtility &bins, std::function< Acts::Vector3(Acts::Vector3)> &transfoGlobalToLocal)
	Create a 3DGrid using a BinUtility. Also determine the corresponding global to local transform and grid mapping function.
MaterialGrid2D	mapMaterialPoints (Grid2D &grid)
	Average the material collected in a 2D grid and use it to create a 2D material grid.
MaterialMapper< detail::Grid < Material::ParametersVector, detail::EquidistantAxis, detail::EquidistantAxis > >	materialMapperRZ (const std::function< size_t(std::array< size_t, 2 > binsRZ, std::array< size_t, 2 > nBinsRZ)> &materialVectorToGridMapper, std::vector< double > rPos, std::vector< double > zPos, const std::vector< Acts::Material > &material, double lengthUnit=UnitConstants::mm)
MaterialMapper< detail::Grid < Material::ParametersVector, detail::EquidistantAxis, detail::EquidistantAxis, detail::EquidistantAxis > >	materialMapperXYZ (const std::function< size_t(std::array< size_t, 3 > binsXYZ, std::array< size_t, 3 > nBinsXYZ)> &materialVectorToGridMapper, std::vector< double > xPos, std::vector< double > yPos, std::vector< double > zPos, const std::vector< Material > &material, double lengthUnit=UnitConstants::mm)
std::ostream &	operator<< (std::ostream &os, const MaterialSlab &materialSlab)
std::ostream &	operator<< (std::ostream &os, const ConstrainedStep &step)
std::tuple< VariantCovariance, VariantTransportJacobian >	transportCovarianceToBound (const GeometryContext &gctx, const Surface &surface, const FreeVector &parameters, CovarianceCache &cCache)
std::tuple< VariantCovariance, VariantTransportJacobian >	transportCovarianceToCurvilinear (const Vector3 &direction, CovarianceCache &cCache)
std::tuple< VariantCovariance, VariantTransportJacobian >	transportCovarianceToFree (CovarianceCache &cCache)
std::error_code	make_error_code (EigenStepperError e)
std::error_code	make_error_code (Acts::MultiStepperError e)
std::error_code	make_error_code (Acts::PropagatorError e)
template<typename spacepoint_iterator_t >
std::optional< BoundVector >	estimateTrackParamsFromSeed (spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd, const Logger &logger=getDummyLogger())
template<typename spacepoint_iterator_t >
std::optional< BoundVector >	estimateTrackParamsFromSeed (const GeometryContext &gctx, spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd, const Surface &surface, const Vector3 &bField, ActsScalar bFieldMin, const Acts::Logger &logger=getDummyLogger(), ActsScalar mass=139.57018 *UnitConstants::MeV)
template<typename external_spacepoint_t >
LinCircle	transformCoordinates (const InternalSpacePoint< external_spacepoint_t > &sp, const InternalSpacePoint< external_spacepoint_t > &spM, bool bottom)
	Transform two spacepoints to a u-v space circle.
template<typename external_spacepoint_t , typename callable_t >
LinCircle	transformCoordinates (const external_spacepoint_t &sp, const external_spacepoint_t &spM, bool bottom, callable_t &&extractFunction)
template<typename external_spacepoint_t >
void	transformCoordinates (Acts::SpacePointData &spacePointData, const std::vector< InternalSpacePoint< external_spacepoint_t > * > &vec, const InternalSpacePoint< external_spacepoint_t > &spM, bool bottom, std::vector< LinCircle > &linCircleVec)
	Transform a vector of spacepoints to u-v space circles with respect to a given middle spacepoint.
template<typename external_spacepoint_t , typename callable_t >
void	transformCoordinates (Acts::SpacePointData &spacePointData, const std::vector< external_spacepoint_t * > &vec, const external_spacepoint_t &spM, bool bottom, std::vector< LinCircle > &linCircleVec, callable_t &&extractFunction)
template<typename external_spacepoint_t >
bool	xyzCoordinateCheck (Acts::SpacePointData &spacePointData, const Acts::SeedFinderConfig< external_spacepoint_t > &config, const Acts::InternalSpacePoint< external_spacepoint_t > &sp, const double *spacepointPosition, double *outputCoordinates)
	Check the compatibility of spacepoint coordinates in xyz assuming the Bottom-Middle direction with the strip meassument details.
std::ostream &	operator<< (std::ostream &os, const std::tuple< const Surface &, const GeometryContext & > &tup)
bool	operator== (const SurfaceBounds &lhs, const SurfaceBounds &rhs)
bool	operator!= (const SurfaceBounds &lhs, const SurfaceBounds &rhs)
std::ostream &	operator<< (std::ostream &os, const SurfaceBounds &sb)
std::error_code	make_error_code (Acts::SurfaceError e)
std::error_code	make_error_code (Acts::CombinatorialKalmanFilterError e)
std::ostream &	operator<< (std::ostream &os, const TrackSelector::Config &cuts)
std::ostream &	operator<< (std::ostream &os, const TrackSelector::EtaBinnedConfig &cfg)
AtlasBetheHeitlerApprox< 6, 5 >	makeDefaultBetheHeitlerApprox ()
std::error_code	make_error_code (GsfError e)
void	reduceMixtureWithKLDistance (std::vector< GsfComponent > &cmpCache, std::size_t maxCmpsAfterMerge, const Surface &surface)
std::error_code	make_error_code (Acts::KalmanFitterError e)
template<typename MatrixType >
MatrixType	bitsetToMatrix (const std::bitset< MatrixType::RowsAtCompileTime *MatrixType::ColsAtCompileTime > bs)
template<typename Derived >
auto	matrixToBitset (const Eigen::PlainObjectBase< Derived > &m)
template<typename A , typename B >
ActsMatrix < A::RowsAtCompileTime, B::ColsAtCompileTime >	blockedMult (const A &a, const B &b)
	Perform a blocked matrix multiplication, avoiding Eigen GEMM methods.
template<typename MatrixType , typename ResultType = MatrixType>
std::optional< ResultType >	safeInverse (const MatrixType &m) noexcept
template<typename T >
constexpr T	safeExp (T val) noexcept
BinUtility	adjustBinUtility (const BinUtility &bu, const RadialBounds &rBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of radial bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CylinderBounds &cBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of cylinder bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const RectangleBounds &pBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of plane bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const TrapezoidBounds &pBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of plane bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const Surface &surface, const GeometryContext &gctx)
	adjust the BinUtility bu to a surface
BinUtility	adjustBinUtility (const BinUtility &bu, const CylinderVolumeBounds &cBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of cylinder volume bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CutoutCylinderVolumeBounds &cBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of cutout cylinder volume bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CuboidVolumeBounds &cBounds, const Transform3 &transform)
	adjust the BinUtility bu to the dimensions of cuboid volume bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const Volume &volume)
	adjust the BinUtility bu to a volume
const std::vector< std::string > &	binningValueNames ()
	screen output option
std::ostream &	operator<< (std::ostream &sl, const BinUtility &bgen)
	Overload of << operator for std::ostream for debug output.
template<typename box_t >
box_t *	make_octree (std::vector< std::unique_ptr< box_t >> &store, const std::vector< box_t * > &prims, size_t max_depth=1, typename box_t::value_type envelope1=0)
template<typename T , typename U , size_t V>
std::ostream &	operator<< (std::ostream &os, const AxisAlignedBoundingBox< T, U, V > &box)
template<typename container_type , typename container_type_iter = decltype(std::begin(std::declval<container_type>())), typename = decltype(std::end(std::declval<container_type>()))>
constexpr auto	enumerate (container_type &&iterable)
template<typename mixture_t , typename projector_t = Acts::Identity>
auto	reduceGaussianMixture (const mixture_t &mixture, const Surface &surface, MixtureReductionMethod method, projector_t &&projector=projector_t{})
constexpr HashedString	hashString (std::string_view s)
template<typename T >
std::vector< T * >	unpack_shared_vector (const std::vector< std::shared_ptr< T >> &items)
template<typename T >
std::vector< const T * >	unpack_shared_vector (const std::vector< std::shared_ptr< const T >> &items)
template<typename T >
std::vector< const T * >	unpack_shared_const_vector (const std::vector< std::shared_ptr< T >> &items)
template<std::size_t kDIM, typename value_type >
std::array< value_type, kDIM >	to_array (const std::vector< value_type > &vecvals)
template<template< size_t > class Callable, size_t N, size_t NMAX, typename... Args>
auto	template_switch (size_t v, Args &&...args)
	Dispatch a call based on a runtime value on a function taking the value at compile time.
template<size_t N, size_t NMAX, typename Lambda , typename... Args>
auto	template_switch_lambda (size_t v, Lambda &&func, Args &&...args)
template<typename T , typename U >
T	clampValue (U value)
template<typename T >
std::array< typename T::value_type, 2u >	min_max (const T &tseries)
template<typename T >
std::tuple< typename T::value_type, ActsScalar >	range_medium (const T &tseries)
template<typename T , size_t N, class Point1 , class Point2 = Point1, class Point3 = Point2, typename = std::enable_if_t< detail::can_interpolate<Point1, Point2, Point3, T>::value>>
T	interpolate (const Point1 &position, const Point2 &lowerCorner, const Point3 &upperCorner, const std::array< T, N > &values)
	performs linear interpolation inside a hyper box
std::ostream &	operator<< (std::ostream &os, IntersectionStatus status)
	Ostream-operator for the IntersectionStatus enum.
std::unique_ptr< const Logger >	getDefaultLogger (const std::string &name, const Logging::Level &lvl, std::ostream *log_stream=&std::cout)
	get default debug output logger
const Logger &	getDummyLogger ()
template<typename T , size_t D>
std::ostream &	operator<< (std::ostream &os, const Ray< T, D > &ray)
template<typename derived_t >
std::string	toString (const Eigen::MatrixBase< derived_t > &matrix, int precision=4, const std::string &offset="")
std::string	toString (const Acts::Translation3 &translation, int precision=4)
std::string	toString (const Acts::Transform3 &transform, int precision=4, const std::string &offset="")
template<typename T >
Eigen::Matrix< T, 3, 1 >	makeDirectionFromPhiEta (T phi, T eta)
template<typename T >
Eigen::Matrix< T, 3, 1 >	makeDirectionFromPhiTheta (T phi, T theta)
template<typename T >
Eigen::Matrix< T, 2, 1 >	makePhiThetaFromDirection (Eigen::Matrix< T, 3, 1 > unitDir)
template<typename InputVector >
auto	makeCurvilinearUnitU (const Eigen::MatrixBase< InputVector > &direction)
template<typename InputVector >
auto	makeCurvilinearUnitVectors (const Eigen::MatrixBase< InputVector > &direction)
template<typename... R>
auto	zip (R &&...r)
std::error_code	make_error_code (Acts::VertexingError e)
std::ostream &	operator<< (std::ostream &os, const IVisualization3D &hlp)
std::ostream &	operator<< (std::ostream &os, const VersionInfo &vi)
void	from_json (const nlohmann::json &j, Acts::TGeoCylinderDiscSplitter::Config &cdc)
	Read config for cylinder/disc module splitter.
void	to_json (nlohmann::json &j, const Acts::TGeoCylinderDiscSplitter::Config &cdc)
	Write config for cylinder/disc module splitter.
void	sortDetElementsByID (std::vector< dd4hep::DetElement > &det)
std::unique_ptr< const TrackingGeometry >	convertDD4hepDetector (dd4hep::DetElement worldDetElement, const Logger &logger, BinningType bTypePhi=equidistant, BinningType bTypeR=equidistant, BinningType bTypeZ=equidistant, double layerEnvelopeR=UnitConstants::mm, double layerEnvelopeZ=UnitConstants::mm, double defaultLayerThickness=UnitConstants::fm, const std::function< void(std::vector< dd4hep::DetElement > &detectors)> &sortSubDetectors=sortDetElementsByID, const GeometryContext &gctx=GeometryContext(), std::shared_ptr< const IMaterialDecorator > matDecorator=nullptr, std::shared_ptr< const GeometryIdentifierHook > geometryIdentifierHook=std::make_shared< GeometryIdentifierHook >())
	Global method which creates the TrackingGeometry from DD4hep input.
std::shared_ptr< const CylinderVolumeBuilder >	volumeBuilder_dd4hep (dd4hep::DetElement subDetector, const Logger &logger, BinningType bTypePhi=equidistant, BinningType bTypeR=equidistant, BinningType bTypeZ=equidistant, double layerEnvelopeR=UnitConstants::mm, double layerEnvelopeZ=UnitConstants::mm, double defaultLayerThickness=UnitConstants::fm)
	Method internally used to create an Acts::CylinderVolumeBuilder.
std::shared_ptr< const CylinderVolumeHelper >	cylinderVolumeHelper_dd4hep (const Logger &logger)
void	collectSubDetectors_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &subdetectors, const Logger &logger)
void	collectCompounds_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &compounds)
void	collectLayers_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &layers, const Logger &logger)
void	decodeBinning (dd4hep::rec::VariantParameters &variantParams, const xml_comp_t &xmlBinning, const std::string &bname, const std::vector< std::string > &bvals)
std::vector < Acts::Experimental::ProtoBinning >	convertBinning (const dd4hep::DetElement &dd4hepElement, const std::string &bname)
	This method converts the DD4hep binning into the Acts ProtoBinning.
template<typename T >
T	getParam (const std::string &key, dd4hep::DetElement &elt)
dd4hep::rec::VariantParameters &	getParams (dd4hep::DetElement &elt)
const dd4hep::rec::VariantParameters &	getParams (const dd4hep::DetElement &elt)
template<typename T >
T	getParamOr (const std::string &key, const dd4hep::DetElement &elt, T alternative)
bool	hasParam (const std::string &key, dd4hep::DetElement &elt)
bool	hasParams (dd4hep::DetElement &elt)
template<typename value_type >
value_type	getAttrValueOr (const dd4hep::xml::Component &node, const std::string &attrName, const value_type &fallbackValue)
	Helper method to get an attribute with fallback.
template<typename value_type >
std::vector< value_type >	extractSeries (const dd4hep::DetElement &dd4hepElement, const std::string &bname, const value_type &unitConversion=1)
	A simple helper function to extract a series.
Transform3	extractTransform (const dd4hep::DetElement &dd4hepElement, const std::string &bname, const ActsScalar unitConversion=1.)
	A simple helper function to extract a transform.
void	addCylinderLayerProtoMaterial (dd4hep::DetElement detElement, Layer &cylinderLayer, const Logger &logger=getDummyLogger())
void	addDiscLayerProtoMaterial (dd4hep::DetElement detElement, Layer &discLayer, const Logger &logger=getDummyLogger())
void	addLayerProtoMaterial (const dd4hep::rec::VariantParameters &params, Layer &layer, const std::vector< std::pair< const std::string, Acts::BinningOption > > &binning, const Logger &logger=getDummyLogger())
std::shared_ptr < Acts::ProtoSurfaceMaterial >	createProtoMaterial (const dd4hep::rec::VariantParameters &params, const std::string &valueTag, const std::vector< std::pair< const std::string, Acts::BinningOption > > &binning, const Logger &logger=getDummyLogger())
std::ostream &	operator<< (std::ostream &os, FpeType type)
void	to_json (nlohmann::json &j, const Transform3 &t)
void	from_json (const nlohmann::json &j, Transform3 &t)
void	to_json (nlohmann::json &j, const Extent &e)
void	from_json (const nlohmann::json &j, Extent &e)
template<class T , class decorator_t >
void	decorateJson ([[maybe_unused]] const decorator_t *decorator,[[maybe_unused]] const T &src,[[maybe_unused]] nlohmann::json &dest)
template<class T , class decorator_t >
void	decorateJson ([[maybe_unused]] const decorator_t *decorator,[[maybe_unused]] const T *src,[[maybe_unused]] nlohmann::json &dest)
void	to_json (nlohmann::json &j, const Material &t)
void	from_json (const nlohmann::json &j, Material &t)
void	to_json (nlohmann::json &j, const MaterialSlab &t)
void	from_json (const nlohmann::json &j, MaterialSlab &t)
void	from_json (const nlohmann::json &j, MaterialSlabMatrix &t)
void	to_json (nlohmann::json &j, const volumeMaterialPointer &material)
void	from_json (const nlohmann::json &j, volumeMaterialPointer &material)
void	to_json (nlohmann::json &j, const surfaceMaterialPointer &material)
void	from_json (const nlohmann::json &j, surfaceMaterialPointer &material)
void	to_json (nlohmann::json &j, const ProtoVolume &pv)
void	from_json (const nlohmann::json &j, ProtoVolume &pv)
void	to_json (nlohmann::json &j, const ProtoDetector &pd)
void	from_json (const nlohmann::json &j, ProtoDetector &pd)
void	to_json (nlohmann::json &j, const SurfaceBounds &bounds)
void	to_json (nlohmann::json &j, const SurfaceAndMaterialWithContext &surface)
	Conversion of a pair of surface and material used for the material mapping.
void	to_json (nlohmann::json &j, const Surface &surface)
void	to_json (nlohmann::json &j, const std::shared_ptr< const Surface > &surface)
void	toJson (nlohmann::json &j, const std::shared_ptr< const Surface > &surface, const Acts::GeometryContext &gctx)
std::shared_ptr< Surface >	surfaceFromJson (const nlohmann::json &j)
template<typename surface_t , typename bounds_t >
std::shared_ptr< surface_t >	surfaceFromJsonT (const nlohmann::json &j)
void	to_json (nlohmann::json &j, const BinningData &bd)
void	from_json (const nlohmann::json &j, BinningData &bd)
void	to_json (nlohmann::json &j, const BinUtility &bu)
void	from_json (const nlohmann::json &j, BinUtility &bu)
template<typename Type >
void	to_json (nlohmann::json &j, const Range1D< Type > &r)
template<typename Type >
void	from_json (const nlohmann::json &j, Range1D< Type > &r)
void	to_json (nlohmann::json &j, const VolumeBounds &bounds)
void	to_json (nlohmann::json &j, const TrackingVolumeAndMaterial &volume)
void	to_json (nlohmann::json &j, const Acts::TrackingVolume &volume)
	Conversion of a tracking volume.
	ACTS_VERBOSE ("Reading JSON material description from: "<< jFileName)
std::ifstream	ifj (jFileName.c_str())
	if (!ifj.good())
	if (jFileName.find(".cbor")!=std::string::npos)
	ACTS_VERBOSE ("JSON material description read complete")
template<>
void	decorateJson< Acts::SurfaceAndMaterialWithContext > (const ITrackingGeometryJsonDecorator *decorator, const Acts::SurfaceAndMaterialWithContext &src, nlohmann::json &dest)
template<>
void	decorateJson< Acts::TrackingVolumeAndMaterial > (const ITrackingGeometryJsonDecorator *decorator, const Acts::TrackingVolumeAndMaterial &src, nlohmann::json &dest)
template<>
void	decorateJson< Acts::IVolumeMaterial > (const IVolumeMaterialJsonDecorator *decorator, const Acts::IVolumeMaterial *src, nlohmann::json &dest)
template<>
void	decorateJson< Acts::ISurfaceMaterial > (const IVolumeMaterialJsonDecorator *decorator, const Acts::ISurfaceMaterial *src, nlohmann::json &dest)
template<typename track_container_t , typename traj_t , template< typename > class holder_t>
std::unordered_map< int, std::vector< int > >	dbscanTrackClustering (std::multimap< int, std::pair< int, std::vector< int >>> &trackMap, const Acts::TrackContainer< track_container_t, traj_t, holder_t > &tracks, float epsilon=0.07, int minPoints=2)
	ACTS_STATIC_CHECK_CONCEPT (TrackContainerBackend, MutablePodioTrackContainer)
	ACTS_STATIC_CHECK_CONCEPT (ConstTrackContainerBackend, ConstPodioTrackContainer)
	ACTS_STATIC_CHECK_CONCEPT (ConstMultiTrajectoryBackend, ConstPodioTrackStateContainer)
	ACTS_STATIC_CHECK_CONCEPT (MutableMultiTrajectoryBackend, MutablePodioTrackStateContainer)
TrackingVolumePtr	constructCylinderVolume (const GeometryContext &gctx, double surfaceHalfLengthZ, double surfaceR, double surfaceRstagger, double surfaceZoverlap, double layerEnvelope, double volumeEnvelope, double innerVolumeR, double outerVolumeR, const std::string &name)
	helper function to create a cylinder
MutableTrackingVolumePtr	constructContainerVolume (const GeometryContext &gctx, TrackingVolumePtr iVolume, TrackingVolumePtr oVolume, double hVolumeR, double hVolumeHalflength, const std::string &name)
	helper function to create a container
std::shared_ptr< const TrackingGeometry >	trackingGeometry ()
	create a small tracking geometry to map some dummy material on
static bool	isEqual (const BinningData &ba, const BinningData &bb, float tolerance)
static bool	isEqual (const BinUtility &ba, const BinUtility &bb, float tolerance)
static bool	isEqual (const Acts::Extent &ea, const Acts::Extent &eb, Acts::ActsScalar tolerance=0.)

Variables
static constexpr ActsScalar	s_epsilon
	Tolerance for being numerical equal for geometry building.
static constexpr ActsScalar	s_onSurfaceTolerance = 1e-4
static constexpr ActsScalar	s_curvilinearProjTolerance = 0.999995
static constexpr TrackIndexType	kTrackIndexInvalid
constexpr Envelope	zeroEnvelope = {0, 0}
constexpr ExtentEnvelope	zeroEnvelopes
static const Transform3	s_planeXY = Transform3::Identity()
static const Transform3	s_planeYZ
static const Transform3	s_planeZX
template<typename stepper , typename state = typename stepper::State>
constexpr bool	StepperConcept
template<typename stepper >
constexpr bool	StepperStateConcept
constexpr size_t	MAX_SEG_PER_NODE = 1000
constexpr size_t	N_SEG_CONNS = 6
constexpr int	PolygonDynamic = -1
	Tag to trigger specialization of a dynamic polygon.
static const InfiniteBounds	s_noBounds {}
template<typename accessor >
constexpr bool	SourceLinkAccessorConcept
static constexpr double	s_normalizationTolerance = 1.e-4
	The tolerated difference to 1 to accept weights as normalized.
static const std::vector < BinningValue >	s_binningValues
	static list of all binning values
static constexpr std::uint8_t	s_maximumNumberOfIntersections = 2
template<typename fitter >
constexpr bool	LinearizerConcept
template<typename finder >
constexpr bool	VertexFinderConcept
template<typename fitter >
constexpr bool	VertexFitterConcept
static ViewConfig	s_viewParameter = ViewConfig({0, 0, 255})
static ViewConfig	s_viewMeasurement = ViewConfig({255, 102, 0})
static ViewConfig	s_viewPredicted = ViewConfig({51, 204, 51})
static ViewConfig	s_viewFiltered = ViewConfig({255, 255, 0})
static ViewConfig	s_viewSmoothed = ViewConfig({0, 102, 255})
static ViewConfig	s_viewSensitive = ViewConfig({0, 180, 240})
static ViewConfig	s_viewPassive = ViewConfig({240, 280, 0})
static ViewConfig	s_viewVolume = ViewConfig({220, 220, 0})
static ViewConfig	s_viewGrid = ViewConfig({220, 0, 0})
static ViewConfig	s_viewLine = ViewConfig({0, 0, 220})
static std::vector< std::tuple < std::string, BinningValue > >	allowedBinnings
	type {typeIn}
nlohmann::json	jin
	else
auto	maps = jmConverter.jsonToMaterialMaps(jin)
	m_surfaceMaterialMap = maps.first
	m_volumeMaterialMap = maps.second
GeometryContext	tgContext = GeometryContext()
std::shared_ptr< const TrackingGeometry >	tGeometry = trackingGeometry()
Transform3	aTransform

Detailed Description

Acts includes to create all necessary definitions.

Note

This file is foreseen for the Geometry module to replace Extent

Typedef Documentation

using Acts::AlignmentMatrix = typedef ActsMatrix<eAlignmentSize, eAlignmentSize>

Definition at line 38 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 38 of file Alignment.hpp

using Acts::AlignmentRowVector = typedef ActsMatrix<1, eAlignmentSize>

Definition at line 37 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 37 of file Alignment.hpp

using Acts::AlignmentToBoundMatrix = typedef ActsMatrix<eBoundSize, eAlignmentSize>

Definition at line 40 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 40 of file Alignment.hpp

using Acts::AlignmentToPathMatrix = typedef ActsMatrix<1, eAlignmentSize>

Definition at line 41 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 41 of file Alignment.hpp

using Acts::AlignmentToPositionMatrix = typedef ActsMatrix<3, eAlignmentSize>

Definition at line 39 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 39 of file Alignment.hpp

using Acts::AlignmentVector = typedef ActsVector<eAlignmentSize>

Definition at line 36 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 36 of file Alignment.hpp

using Acts::Any = typedef AnyBase<sizeof(void*)>

Definition at line 507 of file Any.hpp.

View newest version in sPHENIX GitHub at line 507 of file Any.hpp

using Acts::AxisScalar = typedef Vector3::Scalar

Definition at line 47 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 47 of file SurfaceArrayCreator.hpp

using Acts::BoundaryIntersection = typedef ObjectIntersection<BoundarySurface, Surface>

Intersection with a BoundarySurface.

Definition at line 79 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 79 of file TrackingVolume.hpp

using Acts::BoundaryMultiIntersection = typedef ObjectMultiIntersection<BoundarySurface, Surface>

Multi-intersection with a BoundarySurface.

Definition at line 82 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 82 of file TrackingVolume.hpp

using Acts::BoundarySurface = typedef BoundarySurfaceT<TrackingVolume>

BoundarySurface of a volume.

Definition at line 77 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 77 of file TrackingVolume.hpp

using Acts::BoundarySurfacePtr = typedef std::shared_ptr<const BoundarySurfaceT<AbstractVolume>>

Definition at line 25 of file AbstractVolume.hpp.

View newest version in sPHENIX GitHub at line 25 of file AbstractVolume.hpp

using Acts::BoundMatrix = typedef ActsMatrix<eBoundSize, eBoundSize>

Definition at line 118 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 118 of file TrackParametrization.hpp

using Acts::BoundSquareMatrix = typedef ActsSquareMatrix<eBoundSize>

Definition at line 119 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 119 of file TrackParametrization.hpp

using Acts::BoundToFreeMatrix = typedef ActsMatrix<eFreeSize, eBoundSize>

Definition at line 121 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 121 of file TrackParametrization.hpp

using Acts::BoundTrackParameters = typedef GenericBoundTrackParameters<ParticleHypothesis>

BoundTrackParameters can hold any kind of charge.

Definition at line 33 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 33 of file TrackParameters.hpp

using Acts::BoundVariantMeasurement = typedef VariantMeasurement<BoundIndices>

Variant that can hold all possible bound measurements.

Definition at line 234 of file Measurement.hpp.

View newest version in sPHENIX GitHub at line 234 of file Measurement.hpp

using Acts::BoundVector = typedef ActsVector<eBoundSize>

Definition at line 117 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 117 of file TrackParametrization.hpp

using Acts::CalibrationContext = typedef std::any

This is the central definition of the Acts payload object regarding detector calibration.

It is propagated through the code to allow for event/thread dependent calibration

Definition at line 26 of file CalibrationContext.hpp.

View newest version in sPHENIX GitHub at line 26 of file CalibrationContext.hpp

using Acts::ColorRGB = typedef std::array<int, 3>

The color typedef. It's an array of three numbers [0, 255] representing the RGB color values.

Definition at line 19 of file ViewConfig.hpp.

View newest version in sPHENIX GitHub at line 19 of file ViewConfig.hpp

template<typename T >

using Acts::ConstTrackAccessor = typedef TrackAccessorBase<T, true>

Definition at line 385 of file TrackContainer.hpp.

View newest version in sPHENIX GitHub at line 385 of file TrackContainer.hpp

using Acts::CurvilinearTrackParameters = typedef GenericCurvilinearTrackParameters<ParticleHypothesis>

CurvilinearTrackParameters can hold any kind of charge.

Definition at line 36 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 36 of file TrackParameters.hpp

using Acts::DefaultExtension = typedef detail::GenericDefaultExtension<double>

A typedef for the default GenericDefaultExtension with double.

Definition at line 16 of file DefaultExtension.hpp.

View newest version in sPHENIX GitHub at line 16 of file DefaultExtension.hpp

using Acts::DenseEnvironmentExtension = typedef detail::GenericDenseEnvironmentExtension<double>

A typedef for the default GenericDenseEnvironmentExtension with double.

Definition at line 21 of file DenseEnvironmentExtension.hpp.

View newest version in sPHENIX GitHub at line 21 of file DenseEnvironmentExtension.hpp

typedef std::pair< SurfaceMaterialMap, VolumeMaterialMap > Acts::DetectorMaterialMaps

Definition at line 27 of file IMaterialWriter.hpp.

View newest version in sPHENIX GitHub at line 27 of file IMaterialWriter.hpp

using Acts::EAxis = typedef Acts::detail::EquidistantAxis

Definition at line 31 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 31 of file MaterialGridHelper.hpp

using Acts::Envelope = typedef std::array<ActsScalar, 2>

Definition at line 27 of file Extent.hpp.

View newest version in sPHENIX GitHub at line 27 of file Extent.hpp

using Acts::ExtentEnvelope = typedef std::array<Envelope, binValues>

Definition at line 28 of file Extent.hpp.

View newest version in sPHENIX GitHub at line 28 of file Extent.hpp

using Acts::FreeMatrix = typedef ActsMatrix<eFreeSize, eFreeSize>

Definition at line 125 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 125 of file TrackParametrization.hpp

using Acts::FreeSquareMatrix = typedef ActsSquareMatrix<eFreeSize>

Definition at line 126 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 126 of file TrackParametrization.hpp

using Acts::FreeToBoundMatrix = typedef ActsMatrix<eBoundSize, eFreeSize>

Definition at line 128 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 128 of file TrackParametrization.hpp

using Acts::FreeToPathMatrix = typedef ActsMatrix<1, eFreeSize>

Definition at line 129 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 129 of file TrackParametrization.hpp

using Acts::FreeTrackParameters = typedef GenericFreeTrackParameters<ParticleHypothesis>

FreeTrackParameters can hold any kind of charge.

Definition at line 38 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 38 of file TrackParameters.hpp

using Acts::FreeVariantMeasurement = typedef VariantMeasurement<FreeIndices>

Variant that can hold all possible free measurements.

Definition at line 238 of file Measurement.hpp.

View newest version in sPHENIX GitHub at line 238 of file Measurement.hpp

using Acts::FreeVector = typedef ActsVector<eFreeSize>

Definition at line 124 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 124 of file TrackParametrization.hpp

using Acts::GeometryContext = typedef ContextType

This is the central definition of the Acts payload object regarding detector geometry status (e.g. alignment)

It is propagated through the code to allow for event/thread dependent geometry changes

Definition at line 26 of file GeometryContext.hpp.

View newest version in sPHENIX GitHub at line 26 of file GeometryContext.hpp

using Acts::Grid2D = typedef Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis>

Definition at line 33 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 33 of file MaterialGridHelper.hpp

using Acts::Grid3D = typedef Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis, EAxis>

Definition at line 35 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 35 of file MaterialGridHelper.hpp

using Acts::HashedString = typedef std::uint32_t

Definition at line 17 of file HashedString.hpp.

View newest version in sPHENIX GitHub at line 17 of file HashedString.hpp

using Acts::IdentifiedPolyhedron = typedef std::tuple<std::string, bool, Polyhedron>

Definition at line 57 of file PolyhedronSurfacesTests.cpp.

View newest version in sPHENIX GitHub at line 57 of file PolyhedronSurfacesTests.cpp

using Acts::Intersection2D = typedef Intersection<2>

Definition at line 112 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 112 of file Intersection.hpp

using Acts::Intersection3D = typedef Intersection<3>

Definition at line 113 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 113 of file Intersection.hpp

typedef BinnedArray< LayerPtr > Acts::LayerArray

A BinnedArray to a std::shared_ptr of a layer.

Layers are constructed with shared_ptr factories, hence the layer array is describes as:

Definition at line 24 of file ILayerArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 24 of file ILayerArrayCreator.hpp

using Acts::LayerIntersection = typedef ObjectIntersection<Layer, Surface>

Intersection with Layer.

Definition at line 72 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 72 of file TrackingVolume.hpp

using Acts::LayerMultiIntersection = typedef ObjectMultiIntersection<Layer, Surface>

Multi-intersection with Layer.

Definition at line 74 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 74 of file TrackingVolume.hpp

typedef std::shared_ptr< const Layer > Acts::LayerPtr

A std::shared_ptr to a Layer.

Definition at line 22 of file ILayerArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 22 of file ILayerArrayCreator.hpp

typedef std::vector< LayerPtr > Acts::LayerVector

A vector of std::shared_ptr to layers.

Definition at line 26 of file ILayerArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 26 of file ILayerArrayCreator.hpp

using Acts::MagneticFieldContext = typedef ContextType

This is the central definition of the Acts payload object regarding magnetic field status.

It is propagated through the code to allow for event/thread dependent magnetic field changes

Definition at line 26 of file MagneticFieldContext.hpp.

View newest version in sPHENIX GitHub at line 26 of file MagneticFieldContext.hpp

using Acts::MaterialGrid2D = typedef Acts::detail::Grid<Acts::Material::ParametersVector, EAxis, EAxis>

Definition at line 37 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 37 of file MaterialGridHelper.hpp

using Acts::MaterialGrid3D = typedef Acts::detail::Grid<Acts::Material::ParametersVector, EAxis, EAxis, EAxis>

Definition at line 39 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 39 of file MaterialGridHelper.hpp

using Acts::MaterialGridAxisData = typedef std::tuple<double, double, size_t>

Definition at line 41 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 41 of file MaterialGridHelper.hpp

using Acts::MaterialSlabMatrix = typedef std::vector<MaterialSlabVector>

Definition at line 89 of file MaterialSlab.hpp.

View newest version in sPHENIX GitHub at line 89 of file MaterialSlab.hpp

using Acts::MaterialSlabVector = typedef std::vector<MaterialSlab>

Definition at line 88 of file MaterialSlab.hpp.

View newest version in sPHENIX GitHub at line 88 of file MaterialSlab.hpp

using Acts::MultiIntersection3D = typedef boost::container::static_vector<Intersection3D, s_maximumNumberOfIntersections>

Definition at line 118 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 118 of file Intersection.hpp

typedef std::shared_ptr< Layer > Acts::MutableLayerPtr

Definition at line 48 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 48 of file Layer.hpp

typedef std::shared_ptr< TrackingVolume > Acts::MutableTrackingVolumePtr

Definition at line 16 of file IConfinedTrackingVolumeBuilder.hpp.

View newest version in sPHENIX GitHub at line 16 of file IConfinedTrackingVolumeBuilder.hpp

typedef std::vector< MutableTrackingVolumePtr > Acts::MutableTrackingVolumeVector

Definition at line 17 of file IConfinedTrackingVolumeBuilder.hpp.

View newest version in sPHENIX GitHub at line 17 of file IConfinedTrackingVolumeBuilder.hpp

using Acts::NetworkBatchInput = typedef Eigen::Array<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>

Definition at line 18 of file OnnxRuntimeBase.hpp.

View newest version in sPHENIX GitHub at line 18 of file OnnxRuntimeBase.hpp

using Acts::NeutralBoundTrackParameters = typedef GenericBoundTrackParameters<NeutralParticleHypothesis>

Definition at line 26 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 26 of file TrackParameters.hpp

using Acts::NeutralCurvilinearTrackParameters = typedef GenericCurvilinearTrackParameters<NeutralParticleHypothesis>

Definition at line 28 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 28 of file TrackParameters.hpp

using Acts::NeutralFreeTrackParameters = typedef GenericFreeTrackParameters<NeutralParticleHypothesis>

Definition at line 30 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 30 of file TrackParameters.hpp

using Acts::NextLayers = typedef std::pair<const Layer*, const Layer*>

Definition at line 49 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 49 of file Layer.hpp

using Acts::OrientedSurface = typedef std::pair<std::shared_ptr<Surface>, Direction>

Definition at line 30 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 30 of file VolumeBounds.hpp

using Acts::OrientedSurfaces = typedef std::vector<OrientedSurface>

Definition at line 31 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 31 of file VolumeBounds.hpp

using Acts::ProjectorBitset = typedef uint64_t

Definition at line 19 of file Types.hpp.

View newest version in sPHENIX GitHub at line 19 of file Types.hpp

using Acts::Ray3D = typedef Ray<ActsScalar, 3>

Definition at line 81 of file Ray.hpp.

View newest version in sPHENIX GitHub at line 81 of file Ray.hpp

using Acts::RecordedMaterial = typedef MaterialInteractor::result_type

Definition at line 33 of file RootMaterialTrackWriter.hpp.

View newest version in sPHENIX GitHub at line 33 of file RootMaterialTrackWriter.hpp

typedef std::pair< std::pair< Acts::Vector3, Acts::Vector3 >, RecordedMaterial > Acts::RecordedMaterialTrack

And recorded material track

• this is start: position, start momentum and the Recorded material

Definition at line 109 of file MaterialInteraction.hpp.

View newest version in sPHENIX GitHub at line 109 of file MaterialInteraction.hpp

using Acts::RecordedMaterialVolumePoint = typedef std::vector<std::pair<Acts::MaterialSlab, std::vector<Acts::Vector3>>>

list of point used in the mapping of a volume

Definition at line 93 of file MaterialSlab.hpp.

View newest version in sPHENIX GitHub at line 93 of file MaterialSlab.hpp

using Acts::SinglyChargedBoundTrackParameters = typedef GenericBoundTrackParameters<SinglyChargedParticleHypothesis>

Definition at line 19 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 19 of file TrackParameters.hpp

using Acts::SinglyChargedCurvilinearTrackParameters = typedef GenericCurvilinearTrackParameters<SinglyChargedParticleHypothesis>

Definition at line 21 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 21 of file TrackParameters.hpp

using Acts::SinglyChargedFreeTrackParameters = typedef GenericFreeTrackParameters<SinglyChargedParticleHypothesis>

Definition at line 23 of file TrackParameters.hpp.

View newest version in sPHENIX GitHub at line 23 of file TrackParameters.hpp

template<typename source_link_iterator_t >

using Acts::SourceLinkAccessorDelegate = typedef Delegate<std::pair<source_link_iterator_t, source_link_iterator_t>( const Surface&)>

Delegate type that retrieves a range of source links to for a given surface to be processed by the CKF

Definition at line 146 of file CombinatorialKalmanFilter.hpp.

View newest version in sPHENIX GitHub at line 146 of file CombinatorialKalmanFilter.hpp

using Acts::SourceLinkSurfaceAccessor = typedef Delegate<const Surface*(const SourceLink&)>

Delegate to unpack the surface associated with a source link.

Definition at line 108 of file SourceLink.hpp.

View newest version in sPHENIX GitHub at line 108 of file SourceLink.hpp

template<typename external_spacepoint_t >

using Acts::SpacePointGrid = typedef detail::Grid< std::vector<std::unique_ptr<InternalSpacePoint<external_spacepoint_t>>>, detail::Axis<detail::AxisType::Equidistant, detail::AxisBoundaryType::Closed>, detail::Axis<detail::AxisType::Variable, detail::AxisBoundaryType::Bound>>

Definition at line 95 of file SpacePointGrid.hpp.

View newest version in sPHENIX GitHub at line 95 of file SpacePointGrid.hpp

typedef std::tuple< std::shared_ptr< const Acts::Surface >, std::shared_ptr< const Acts::ISurfaceMaterial >, Acts::GeometryContext > Acts::SurfaceAndMaterialWithContext

Definition at line 45 of file MaterialMapJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 45 of file MaterialMapJsonConverter.hpp

typedef ObjectIntersection< Surface > Acts::SurfaceIntersection

Typedef of the surface intersection.

Definition at line 42 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 42 of file Layer.hpp

using Acts::SurfaceMatcher = typedef std::function<bool( const GeometryContext& gctx, BinningValue, const Surface*, const Surface*)>

Definition at line 39 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 39 of file SurfaceArrayCreator.hpp

using Acts::SurfaceMaterialMap = typedef std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>

Definition at line 22 of file IMaterialWriter.hpp.

View newest version in sPHENIX GitHub at line 22 of file IMaterialWriter.hpp

using Acts::surfaceMaterialPointer = typedef const Acts::ISurfaceMaterial*

Definition at line 26 of file MaterialJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 26 of file MaterialJsonConverter.hpp

using Acts::SurfaceMatrix = typedef std::vector<SurfaceVector>

Definition at line 42 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 42 of file SurfaceArrayCreator.hpp

using Acts::SurfaceMultiIntersection = typedef ObjectMultiIntersection<Surface>

Typedef of the surface multi-intersection.

Definition at line 50 of file Surface.hpp.

View newest version in sPHENIX GitHub at line 50 of file Surface.hpp

typedef std::shared_ptr< const Surface > Acts::SurfacePtr

Definition at line 21 of file DigitizationModule.hpp.

View newest version in sPHENIX GitHub at line 21 of file DigitizationModule.hpp

typedef std::vector< SurfacePtr > Acts::SurfacePtrVector

Definition at line 22 of file DigitizationModule.hpp.

View newest version in sPHENIX GitHub at line 22 of file DigitizationModule.hpp

typedef std::vector< const Surface * > Acts::SurfaceVector

Definition at line 41 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 41 of file SurfaceArrayCreator.hpp

template<typename T >

using Acts::TrackAccessor = typedef TrackAccessorBase<T, false>

Definition at line 383 of file TrackContainer.hpp.

View newest version in sPHENIX GitHub at line 383 of file TrackContainer.hpp

using Acts::TrackIndexType = typedef std::uint32_t

Definition at line 15 of file Types.hpp.

View newest version in sPHENIX GitHub at line 15 of file Types.hpp

using Acts::TrackingVolumeAndMaterial = typedef std::pair<const Acts::TrackingVolume*, std::shared_ptr<const Acts::IVolumeMaterial>>

Definition at line 48 of file MaterialMapJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 48 of file MaterialMapJsonConverter.hpp

typedef BinnedArray< TrackingVolumePtr > Acts::TrackingVolumeArray

A BinnedArray of a std::shared_tr to a TrackingVolume.

Definition at line 25 of file GlueVolumesDescriptor.hpp.

View newest version in sPHENIX GitHub at line 25 of file GlueVolumesDescriptor.hpp

using Acts::TrackingVolumeBoundaries = typedef std::vector<TrackingVolumeBoundaryPtr>

Definition at line 62 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 62 of file TrackingVolume.hpp

using Acts::TrackingVolumeBoundaryPtr = typedef std::shared_ptr<const BoundarySurfaceT<TrackingVolume>>

Definition at line 61 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 61 of file TrackingVolume.hpp

using Acts::TrackingVolumeOrderPosition = typedef std::pair<TrackingVolumePtr, Vector3>

Definition at line 22 of file TrackingVolumeArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 22 of file TrackingVolumeArrayCreator.hpp

using Acts::TrackingVolumePointer = typedef const Acts::TrackingVolume*

Definition at line 27 of file VolumeJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 27 of file VolumeJsonConverter.hpp

typedef std::shared_ptr< const TrackingVolume > Acts::TrackingVolumePtr

A std::shared_ptr to a tracking volume.

Definition at line 24 of file GlueVolumesDescriptor.hpp.

View newest version in sPHENIX GitHub at line 24 of file GlueVolumesDescriptor.hpp

typedef std::vector< TrackingVolumePtr > Acts::TrackingVolumeVector

A std::vector of a std::shared_ptr to a TrackingVolume.

Definition at line 29 of file ITrackingVolumeArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 29 of file ITrackingVolumeArrayCreator.hpp

using Acts::V3Matrix = typedef std::vector<V3Vector>

Definition at line 45 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 45 of file SurfaceArrayCreator.hpp

using Acts::V3Vector = typedef std::vector<Vector3>

Definition at line 44 of file SurfaceArrayCreator.hpp.

View newest version in sPHENIX GitHub at line 44 of file SurfaceArrayCreator.hpp

using Acts::VariantCovariance = typedef std::variant<BoundSquareMatrix, FreeSquareMatrix>

Definition at line 23 of file CovarianceTransport.hpp.

View newest version in sPHENIX GitHub at line 23 of file CovarianceTransport.hpp

template<typename indices_t >

using Acts::VariantMeasurement = typedef typename detail::VariantMeasurementGenerator< indices_t, detail::kParametersSize<indices_t>>::Type

Variant that can contain all possible measurements in a parameter space.

Template Parameters

indices_t

Parameter index type, determines the full parameter space

Definition at line 230 of file Measurement.hpp.

View newest version in sPHENIX GitHub at line 230 of file Measurement.hpp

using Acts::VariantTransportJacobian = typedef std::variant<BoundMatrix, BoundToFreeMatrix, FreeToBoundMatrix, FreeMatrix>

Definition at line 26 of file CovarianceTransport.hpp.

View newest version in sPHENIX GitHub at line 26 of file CovarianceTransport.hpp

typedef std::shared_ptr< const VolumeBounds > Acts::VolumeBoundsPtr

Definition at line 29 of file AbstractVolume.hpp.

View newest version in sPHENIX GitHub at line 29 of file AbstractVolume.hpp

using Acts::VolumeMaterialMap = typedef std::map<GeometryIdentifier, std::shared_ptr<const IVolumeMaterial>>

Definition at line 25 of file IMaterialWriter.hpp.

View newest version in sPHENIX GitHub at line 25 of file IMaterialWriter.hpp

using Acts::volumeMaterialPointer = typedef const Acts::IVolumeMaterial*

Definition at line 25 of file MaterialJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 25 of file MaterialJsonConverter.hpp

Enumeration Type Documentation

enum Acts::AlignmentIndices : unsigned int

Components of alignment parameters vector.

To be used to access components by named indices instead of just numbers. This must be a regular enum and not a scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Enumerator:

eAlignmentCenter0
eAlignmentCenter1
eAlignmentCenter2
eAlignmentRotation0
eAlignmentRotation1
eAlignmentRotation2
eAlignmentSize

Definition at line 22 of file Alignment.hpp.

View newest version in sPHENIX GitHub at line 22 of file Alignment.hpp

enum Acts::BinningOption

flag for open/closed bins

Enumerator:

open
closed

Definition at line 32 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 32 of file BinningType.hpp

enum Acts::BinningType

, BinningOption & BinningAccess

• BinningType:

  Enumeration to qualify the binning type for the use of the LayerArrayCreator and the TrackingVolumeArrayCreator

  • BinningOption: open: [0,max] closed: 0 -> nextbin -> max -> 0
  • BinningValue necessary access to global positions

Enumerator:

equidistant
arbitrary

Definition at line 29 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 29 of file BinningType.hpp

enum Acts::BinningValue : int

how to take the global / local position

Enumerator:

binX
binY
binZ
binR
binPhi
binRPhi
binH
binEta
binMag
binValues

Definition at line 35 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 35 of file BinningType.hpp

enum Acts::BoundarySurfaceFace

Enum to describe the position of the BoundarySurface respectively to the frame orientatin of the volume, this is mainly meant for code readability.

The different numeration sequences can be found in the documentation of the actual VolumeBounds implementations.

The order of faces is chosen to follow - as much as possible - a circular structure.

Enumerator:

negativeFaceXY
positiveFaceXY
negativeFaceYZ
positiveFaceYZ
negativeFaceZX
positiveFaceZX
cylinderCover
tubeInnerCover
tubeOuterCover
tubeSectorNegativePhi
tubeSectorPositivePhi
tubeSectorInnerCover
tubeSectorOuterCover
trapezoidFaceAlpha
trapezoidFaceBeta
index0
index1
index2
index3
index4
index5
index6
index7
index8
index9
index10
index11
undefinedFace

Definition at line 26 of file BoundarySurfaceFace.hpp.

View newest version in sPHENIX GitHub at line 26 of file BoundarySurfaceFace.hpp

enum Acts::BoundIndices : unsigned int

Components of a bound track parameters vector.

To be used to access components by named indices instead of just numbers. This must be a regular enum and not a scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Enumerator:

eBoundLoc0
eBoundLoc1
eBoundPhi
eBoundTheta
eBoundQOverP
eBoundTime
eBoundSize

Definition at line 37 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 37 of file TrackParametrization.hpp

enum Acts::CombinatorialKalmanFilterError

Definition at line 16 of file CombinatorialKalmanFilterError.hpp.

View newest version in sPHENIX GitHub at line 16 of file CombinatorialKalmanFilterError.hpp

enum Acts::CombinatorialKalmanFilterTargetSurfaceStrategy

Definition at line 50 of file CombinatorialKalmanFilter.hpp.

View newest version in sPHENIX GitHub at line 50 of file CombinatorialKalmanFilter.hpp

enum Acts::CoordinateIndices : unsigned int

Components of coordinate vectors.

To be used to access coordinate components by named indices instead of magic numbers. This must be a regular enum and not a scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts.

This index enum is not user-configurable (in contrast e.g. to the track parameter index enums) since it must be compatible with varying dimensionality (2d-4d) and other access methods (.{x,y,z}() accessors).

Enumerator:

ePos0
ePos1
ePos2
eTime
eMom0
eMom1
eMom2
eEnergy
eX
eY
eZ

Definition at line 43 of file Common.hpp.

View newest version in sPHENIX GitHub at line 43 of file Common.hpp

enum Acts::DelegateType

Ownership enum for Delegate.

Definition at line 21 of file Delegate.hpp.

View newest version in sPHENIX GitHub at line 21 of file Delegate.hpp

enum Acts::DetectorMeasurementInfo : short

Definition at line 37 of file SeedFinder.hpp.

View newest version in sPHENIX GitHub at line 37 of file SeedFinder.hpp

enum Acts::EigenStepperError

Definition at line 16 of file EigenStepperError.hpp.

View newest version in sPHENIX GitHub at line 16 of file EigenStepperError.hpp

enum Acts::FpeType : uint32_t

Definition at line 27 of file FpeMonitor.hpp.

View newest version in sPHENIX GitHub at line 27 of file FpeMonitor.hpp

enum Acts::FreeIndices : unsigned int

Components of a free track parameters vector.

To be used to access components by named indices instead of just numbers. This must be a regular enum and not a scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Enumerator:

eFreePos0
eFreePos1
eFreePos2
eFreeTime
eFreeDir0
eFreeDir1
eFreeDir2
eFreeQOverP
eFreeSize

Definition at line 64 of file TrackParametrization.hpp.

View newest version in sPHENIX GitHub at line 64 of file TrackParametrization.hpp

enum Acts::GsfError

Definition at line 16 of file GsfError.hpp.

View newest version in sPHENIX GitHub at line 16 of file GsfError.hpp

enum Acts::IntersectionStatus : int

Status enum.

Definition at line 25 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 25 of file Intersection.hpp

enum Acts::KalmanFitterError

Definition at line 16 of file KalmanFitterError.hpp.

View newest version in sPHENIX GitHub at line 16 of file KalmanFitterError.hpp

enum Acts::KalmanFitterTargetSurfaceStrategy

Definition at line 49 of file KalmanFitter.hpp.

View newest version in sPHENIX GitHub at line 49 of file KalmanFitter.hpp

enum Acts::LayerType

For code readability, it distinguishes between different type of layers, which steers the behaviour in the navigation

Enumerator:

navigation
passive
active

Definition at line 55 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 55 of file Layer.hpp

enum Acts::LinIndices : unsigned int

Enum to access the components of a track parameter vector.

Here, we parametrize the track via a 4D point on the track, the momentum angles of the particle at that point, and q/p or 1/p.

Note

It would make sense to rename these parameters if they are used outside of track linearization.

This must be a regular enum and not a scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Enumerator:

eLinPos0
eLinPos1
eLinPos2
eLinTime
eLinPhi
eLinTheta
eLinQOverP
eLinSize
eLinPosSize
eLinMomSize

Definition at line 22 of file LinearizerTrackParameters.hpp.

View newest version in sPHENIX GitHub at line 22 of file LinearizerTrackParameters.hpp

enum Acts::MagneticFieldError

Definition at line 16 of file MagneticFieldError.hpp.

View newest version in sPHENIX GitHub at line 16 of file MagneticFieldError.hpp

enum Acts::MappingType

This enum describes the type of surface material mapping.

Enumerator:

PreMapping
Default
PostMapping
Sensor

Definition at line 23 of file ISurfaceMaterial.hpp.

View newest version in sPHENIX GitHub at line 23 of file ISurfaceMaterial.hpp

enum Acts::MaterialUpdateStage : int

This is a steering enum to tell which material update stage:

• PreUpdate : update on approach of a surface
• FullUpdate : update when passing a surface
• PostUpdate : update when leaving a surface

Definition at line 19 of file Common.hpp.

View newest version in sPHENIX GitHub at line 19 of file Common.hpp

enum Acts::MixtureReductionMethod

Available reduction methods for the reduction of a Gaussian mixture

Definition at line 211 of file GaussianMixtureReduction.hpp.

View newest version in sPHENIX GitHub at line 211 of file GaussianMixtureReduction.hpp

enum Acts::MultiStepperError

Definition at line 16 of file MultiStepperError.hpp.

View newest version in sPHENIX GitHub at line 16 of file MultiStepperError.hpp

enum Acts::NoiseUpdateMode : int

to tell how to deal with noise term in covariance transport

• removeNoise: subtract noise term
• addNoise: add noise term

Enumerator:

removeNoise
addNoise

Definition at line 31 of file Common.hpp.

View newest version in sPHENIX GitHub at line 31 of file Common.hpp

enum Acts::PdgParticle : int32_t

Symbolic values for commonly used PDG particle numbers.

Enumerator:

eInvalid
eElectron
eAntiElectron
ePositron
eMuon
eAntiMuon
eTau
eAntiTau
eGamma
ePionZero
ePionPlus
ePionMinus
eNeutron
eAntiNeutron
eProton
eAntiProton
eLead

Definition at line 16 of file PdgParticle.hpp.

View newest version in sPHENIX GitHub at line 16 of file PdgParticle.hpp

enum Acts::PropagatorError

Definition at line 16 of file PropagatorError.hpp.

View newest version in sPHENIX GitHub at line 16 of file PropagatorError.hpp

enum Acts::SpacePointCandidateType : short

Definition at line 35 of file SeedFinder.hpp.

View newest version in sPHENIX GitHub at line 35 of file SeedFinder.hpp

enum Acts::SurfaceError

Definition at line 16 of file SurfaceError.hpp.

View newest version in sPHENIX GitHub at line 16 of file SurfaceError.hpp

enum Acts::TrackStateFlag

This enum describes the type of TrackState

Enumerator:

MeasurementFlag
ParameterFlag
OutlierFlag
HoleFlag
MaterialFlag
SharedHitFlag
NumTrackStateFlags

Definition at line 23 of file TrackStateType.hpp.

View newest version in sPHENIX GitHub at line 23 of file TrackStateType.hpp

enum Acts::TrackStatePropMask : std::uint8_t

Collection of bit masks to enable steering which components of a track state should be initialized, and which should be left invalid. These mask values can be combined using binary operators, so (TrackStatePropMask::Predicted | TrackStatePropMask::Jacobian) will instruct allocating storage for both predicted parameters (including covariance) and a jacobian. The enum is used as a strong type wrapper around the bits to prevent autoconversion from integer

Definition at line 28 of file TrackStatePropMask.hpp.

View newest version in sPHENIX GitHub at line 28 of file TrackStatePropMask.hpp

enum Acts::VertexingError

Definition at line 16 of file VertexingError.hpp.

View newest version in sPHENIX GitHub at line 16 of file VertexingError.hpp

enum Acts::WrappingCondition

Enumerator:

Undefined	inconsistency detected
Attaching	attach the volumes
Inserting	insert the new volume
Wrapping	wrap the new volume around
CentralInserting	insert the new one into the center
CentralWrapping	wrap the new central volume around
NoWrapping	no inner volume present - no wrapping needed

Definition at line 36 of file CylinderVolumeBuilder.hpp.

View newest version in sPHENIX GitHub at line 36 of file CylinderVolumeBuilder.hpp

Function Documentation

Acts::ACTS_STATIC_CHECK_CONCEPT	(	TrackContainerBackend	,
		MutablePodioTrackContainer
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	TrackContainerBackend	,
		VectorTrackContainer
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	ConstTrackContainerBackend	,
		ConstVectorTrackContainer
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	ConstTrackContainerBackend	,
		ConstPodioTrackContainer
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	ConstMultiTrajectoryBackend	,
		ConstPodioTrackStateContainer
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	MutableMultiTrajectoryBackend	,
		VectorMultiTrajectory
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	ConstMultiTrajectoryBackend	,
		ConstVectorMultiTrajectory
	)

Acts::ACTS_STATIC_CHECK_CONCEPT	(	MutableMultiTrajectoryBackend	,
		MutablePodioTrackStateContainer
	)

Acts::ACTS_VERBOSE

(

"Reading JSON material description from: "<<

jFileName

)

Referenced by Acts::CylinderVolumeHelper::addFaceVolumes(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::addNonSourcelinkState(), Acts::CylinderVolumeBuilder::analyzeContent(), Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::applyBetheHeitler(), Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::applyMultipleScattering(), Acts::Experimental::GeometryIdGenerator::assignGeometryId(), Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::OnnxMetricLearning::buildEdgesWrapper(), Acts::Experimental::DD4hepLayerStructure::builder(), Acts::TGeoLayerBuilder::buildLayers(), Acts::GainMatrixSmoother::calculate(), Acts::PlanarModuleStepper::cellSteps(), Acts::PassiveLayerBuilder::centralLayers(), Acts::DD4hepLayerBuilder::centralLayers(), Acts::DD4hepVolumeBuilder::centralVolumes(), Acts::LayerCreator::checkBinning(), Acts::detail::checkIntersection(), collectLayers_dd4hep(), Acts::VolumeMaterialMapper::collectMaterialSurfaces(), Acts::SurfaceMaterialMapper::collectMaterialVolumes(), Acts::Experimental::collector(), Acts::TrackingVolume::compatibleBoundaries(), Acts::SurfaceArrayCreator::completeBinning(), Acts::Experimental::DetectorVolumeBuilder::construct(), Acts::Experimental::VolumeStructureBuilder::construct(), Acts::Experimental::CylindricalContainerBuilder::construct(), Acts::Experimental::LayerStructureBuilder::construct(), convertDD4hepDetector(), Acts::CylinderVolumeHelper::createContainerTrackingVolume(), Acts::CylinderVolumeHelper::createCylinderLayer(), Acts::CylinderVolumeHelper::createDiscLayer(), Acts::SurfaceArrayCreator::createEquidistantAxis(), Acts::CylinderVolumeHelper::createGapTrackingVolume(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::createSourceLinkTrackStates(), Acts::SurfaceMaterialMapper::createState(), Acts::CylinderVolumeHelper::createTrackingVolume(), Acts::SurfaceArrayCreator::createVariableAxis(), Acts::LayerCreator::cylinderLayer(), Acts::Test::debug_level_test(), Acts::JsonMaterialDecorator::decorate(), Acts::MappingMaterialDecorator::decorate(), Acts::LayerCreator::discLayer(), Acts::PassiveLayerBuilder::endcapLayers(), Acts::DD4hepLayerBuilder::endcapLayers(), Acts::CylinderVolumeHelper::estimateAndCheckDimension(), Acts::KalmanFitter< propagator_t, traj_t >::Actor< parameters_t >::filter(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::filter(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::finalize(), Acts::Experimental::Gx2Fitter< propagator_t, traj_t >::fit(), Acts::GaussianSumFitter< propagator_t, bethe_heitler_approx_t, traj_t >::fit_impl(), Acts::CylinderVolumeHelper::glueTrackingVolumes(), Acts::Experimental::DetectorNavigator::initializeTarget(), Acts::CylinderVolumeHelper::interGlueTrackingVolume(), Acts::detail::kalmanHandleMeasurement(), Acts::detail::kalmanHandleNoMeasurement(), Acts::LayerArrayCreator::layerArray(), Acts::SurfaceMaterialMapper::mapInteraction(), Acts::VolumeMaterialMapper::mapMaterialTrack(), Acts::SurfaceMaterialMapper::mapMaterialTrack(), Acts::KalmanFitter< propagator_t, traj_t >::Actor< parameters_t >::materialInteractor(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::materialInteractor(), Acts::BoostTrackBuilding::operator()(), Acts::CugraphTrackBuilding::operator()(), Acts::OnnxMetricLearning::operator()(), Acts::TorchEdgeClassifier::operator()(), Acts::GainMatrixSmoother::operator()(), Acts::TorchMetricLearning::operator()(), Acts::GainMatrixUpdater::operator()(), Acts::MaterialInteractor::operator()(), Acts::MultiStepperSurfaceReached::operator()(), Acts::PathLimitReached::operator()(), Acts::MaterialCollector::operator()(), Acts::Test::MeasurementsCreator::operator()(), Acts::VolumeCollector< Selector >::operator()(), Acts::SurfaceCollector< Selector >::operator()(), Acts::detail::CorrectedFreeToBoundTransformer::operator()(), Acts::SurfaceReached::operator()(), Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::operator()(), Acts::KalmanFitter< propagator_t, traj_t >::Actor< parameters_t >::operator()(), Acts::Experimental::Gx2Fitter< propagator_t, traj_t >::Actor< parameters_t >::operator()(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::operator()(), Acts::LayerCreator::planeLayer(), Acts::DirectNavigator::postStep(), Acts::DirectNavigator::preStep(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::processSelectedTrackStates(), Acts::ProtoLayerHelper::protoLayers(), Acts::EDM4hepUtil::readTrack(), Acts::DD4hepDetectorSurfaceFactory::recursiveConstruct(), Acts::Experimental::DD4hepVolumeStructure::recursiveParse(), Acts::GreedyAmbiguityResolution::resolve(), Acts::SurfaceMaterialMapper::resolveMaterialSurfaces(), Acts::VolumeMaterialMapper::resolveMaterialVolume(), Acts::KalmanFitter< propagator_t, traj_t >::Actor< parameters_t >::reversedFilter(), Acts::Experimental::detail::CylindricalDetectorHelper::rzphiBoundaries(), Acts::MeasurementSelector::select(), Acts::detail::setupLoopProtection(), Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::step(), Acts::ExaTrkXTime::summary(), Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(), Acts::SurfaceArrayCreator::surfaceArrayOnDisc(), Acts::SurfaceArrayCreator::surfaceArrayOnPlane(), Acts::CylinderVolumeBuilder::trackingVolume(), Acts::KDTreeTrackingGeometryBuilder::translateLayer(), Acts::KDTreeTrackingGeometryBuilder::translateVolume(), Acts::detail::updateSingleSurfaceStatus(), Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::updateSurfaceStatus(), Acts::MeasurementSelector::VariableCut(), Acts::GainMatrixUpdater::visitMeasurement(), volumeBuilder_dd4hep(), Acts::Experimental::GeometryIdGenerator::volumeId(), and Acts::EDM4hepUtil::writeTrack().

Acts::ACTS_VERBOSE

(

"JSON material description read complete"

)

void Acts::addCylinderLayerProtoMaterial	(	dd4hep::DetElement	detElement,
		Layer &	cylinderLayer,
		const Logger &	logger = getDummyLogger()
	)

Helper method to translate DD4hep material to Acts::ISurfaceMaterial

This is used to assign proto material to Cylinder Layers

Parameters

detElement	the DD4hep detector element for which this material is assigned
cylinderLayer	is the target layer
logger	a Logger for output

Definition at line 98 of file DD4hepMaterialConverter.cpp.

View newest version in sPHENIX GitHub at line 98 of file DD4hepMaterialConverter.cpp

References ACTS_VERBOSE, addLayerProtoMaterial(), closed, getParams(), hasParams(), logger(), and open.

Referenced by Acts::DD4hepLayerBuilder::centralLayers().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::addDiscLayerProtoMaterial	(	dd4hep::DetElement	detElement,
		Layer &	discLayer,
		const Logger &	logger = getDummyLogger()
	)

Helper method to translate DD4hep material to Acts::ISurfaceMaterial

Thisis used to assign proto material to Disc Layers

Parameters

detElement	the DD4hep detector element for which this material is assigned
discLayer	is the target layer
logger	a Logger for output

Definition at line 116 of file DD4hepMaterialConverter.cpp.

View newest version in sPHENIX GitHub at line 116 of file DD4hepMaterialConverter.cpp

References ACTS_VERBOSE, addLayerProtoMaterial(), closed, getParams(), hasParams(), logger(), and open.

Referenced by Acts::DD4hepLayerBuilder::endcapLayers().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::addLayerProtoMaterial	(	const dd4hep::rec::VariantParameters &	params,
		Layer &	layer,
		const std::vector< std::pair< const std::string, Acts::BinningOption > > &	binning,
		const Logger &	logger = getDummyLogger()
	)

Helper method to be called for Cylinder and Disc Proto material

For both, cylinder and disc, the closed binning value is "binPhi"

Parameters

params	An instance of DD4hep::VariantParameters
layer	the Layer to assign the proto material
binning	the Binning prescription for the ActsExtension
logger	a Logger for output

Definition at line 59 of file DD4hepMaterialConverter.cpp.

View newest version in sPHENIX GitHub at line 59 of file DD4hepMaterialConverter.cpp

References ACTS_VERBOSE, Acts::Layer::approachDescriptor(), Acts::Surface::assignSurfaceMaterial(), Acts::ApproachDescriptor::containedSurfaces(), createProtoMaterial(), writeMapConfig::surface, and Acts::Layer::surfaceRepresentation().

Referenced by addCylinderLayerProtoMaterial(), and addDiscLayerProtoMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const RadialBounds &	rBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of radial bounds

Parameters

bu	BinUtility at source
rBounds	the Radial bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 34 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 34 of file BinAdjustment.hpp

References arbitrary, Acts::BinUtility::binningData(), binPhi, binR, Acts::RadialBounds::eAveragePhi, Acts::RadialBounds::eHalfPhiSector, Acts::RadialBounds::eMaxR, Acts::RadialBounds::eMinR, Acts::RadialBounds::get(), Acts::Test::maxPhi, maxR, Acts::UnitConstants::min, Acts::Test::minPhi, and minR.

Referenced by adjustBinUtility(), Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::VolumeMaterialMapper::checkAndInsert(), and Acts::SurfaceMaterialMapper::checkAndInsert().

Here is the call graph for this function:

Here is the caller graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CylinderVolumeBounds &	cBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of cylinder volume bounds

Parameters

bu	BinUtility at source
cBounds	the Cylinder volume bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 33 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 33 of file BinAdjustmentVolume.hpp

References arbitrary, Acts::BinUtility::binningData(), binPhi, binR, binZ, Acts::CylinderVolumeBounds::eHalfLengthZ, Acts::CylinderVolumeBounds::eHalfPhiSector, Acts::CylinderVolumeBounds::eMaxR, Acts::CylinderVolumeBounds::eMinR, Acts::CylinderVolumeBounds::get(), Acts::Test::maxPhi, maxR, maxZ, Acts::UnitConstants::min, Acts::Test::minPhi, and minR.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CylinderBounds &	cBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of cylinder bounds

Parameters

bu	BinUtility at source
cBounds	the Cylinder bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 83 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 83 of file BinAdjustment.hpp

References arbitrary, Acts::BinUtility::binningData(), binPhi, binRPhi, binZ, Acts::CylinderBounds::eAveragePhi, Acts::CylinderBounds::eHalfLengthZ, Acts::CylinderBounds::eHalfPhiSector, Acts::CylinderBounds::eR, Acts::CylinderBounds::get(), Acts::Test::maxPhi, Acts::UnitConstants::min, and Acts::Test::minPhi.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CutoutCylinderVolumeBounds &	cBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of cutout cylinder volume bounds

Parameters

bu	BinUtility at source
cBounds	the Cutout Cylinder volume bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 88 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 88 of file BinAdjustmentVolume.hpp

References arbitrary, Acts::BinUtility::binningData(), binPhi, binR, binZ, Acts::CutoutCylinderVolumeBounds::eHalfLengthZ, Acts::CutoutCylinderVolumeBounds::eMaxR, Acts::CutoutCylinderVolumeBounds::eMinR, Acts::CutoutCylinderVolumeBounds::get(), Acts::Test::maxPhi, maxR, maxZ, Acts::UnitConstants::min, Acts::Test::minPhi, and minR.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const RectangleBounds &	pBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of plane bounds

Parameters

bu	BinUtility at source
pBounds	the Rectangle bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 136 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 136 of file BinAdjustment.hpp

References arbitrary, Acts::BinUtility::binningData(), binX, binY, Acts::RectangleBounds::eMaxX, Acts::RectangleBounds::eMaxY, Acts::RectangleBounds::eMinX, Acts::RectangleBounds::eMinY, Acts::RectangleBounds::get(), and Acts::UnitConstants::min.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CuboidVolumeBounds &	cBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of cuboid volume bounds

Parameters

bu	BinUtility at source
cBounds	the Cuboid volume bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 143 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 143 of file BinAdjustmentVolume.hpp

References arbitrary, Acts::BinUtility::binningData(), binX, binY, binZ, Acts::CuboidVolumeBounds::eHalfLengthX, Acts::CuboidVolumeBounds::eHalfLengthY, Acts::CuboidVolumeBounds::eHalfLengthZ, Acts::CuboidVolumeBounds::get(), maxZ, and Acts::UnitConstants::min.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const TrapezoidBounds &	pBounds,
		const Transform3 &	transform
	)

adjust the BinUtility bu to the dimensions of plane bounds

Parameters

bu	BinUtility at source
pBounds	the Trapezoid bounds to adjust to
transform	Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

Definition at line 186 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 186 of file BinAdjustment.hpp

References arbitrary, Acts::BinUtility::binningData(), binX, binY, Acts::TrapezoidBounds::eHalfLengthXnegY, Acts::TrapezoidBounds::eHalfLengthXposY, Acts::TrapezoidBounds::eHalfLengthY, Acts::TrapezoidBounds::get(), Acts::Test::halfX, Acts::Test::halfY, and Acts::UnitConstants::min.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const Volume &	volume
	)

adjust the BinUtility bu to a volume

Parameters

bu	BinUtility at source
volume	Volume to which the adjustment is being done

Returns

new updated BinUtiltiy

Definition at line 195 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 195 of file BinAdjustmentVolume.hpp

References adjustBinUtility(), Acts::Volume::transform(), and Acts::Volume::volumeBounds().

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const Surface &	surface,
		const GeometryContext &	gctx
	)

adjust the BinUtility bu to a surface

Parameters

bu	BinUtility at source
surface	Surface to which the adjustment is being done
gctx	Geometry context to get the surfaces transform

Returns

new updated BinUtiltiy

Definition at line 236 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 236 of file BinAdjustment.hpp

References adjustBinUtility(), Acts::Surface::bounds(), Acts::Surface::Cylinder, Acts::Surface::Disc, Acts::SurfaceBounds::eRectangle, Acts::SurfaceBounds::eTrapezoid, Acts::Surface::Plane, rBounds, Acts::Surface::transform(), Acts::SurfaceBounds::type(), and Acts::Surface::type().

Here is the call graph for this function:

const std::vector<std::string>& Acts::binningValueNames ( )

inline

screen output option

Definition at line 53 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 53 of file BinningType.hpp

Referenced by Acts::TGeoLayerBuilder::buildLayers(), createProtoMaterial(), from_json(), Acts::ProtoLayerHelper::protoLayers(), to_json(), and Acts::Extent::toString().

Here is the caller graph for this function:

template<typename MatrixType >

MatrixType Acts::bitsetToMatrix

(

const std::bitset< MatrixType::RowsAtCompileTime *MatrixType::ColsAtCompileTime >

bs

)

Convert a bitset to a matrix of integers, with each element set to the bit value.

Note

How the bits are assigned to matrix elements depends on the storage type of the matrix being converted (row-major or col-major)

Template Parameters

MatrixType

Matrix type that is produced

Parameters

bs	The bitset to convert

Returns

A matrix with the integer values of the bits from bs

Definition at line 28 of file AlgebraHelpers.hpp.

View newest version in sPHENIX GitHub at line 28 of file AlgebraHelpers.hpp

References i, Acts::UnitConstants::m, merge_hashes::p, and parse_cmake_options::rows.

template<typename A , typename B >

ActsMatrix<A::RowsAtCompileTime, B::ColsAtCompileTime> Acts::blockedMult ( const A &  a, const B &  b  )

inline

Perform a blocked matrix multiplication, avoiding Eigen GEMM methods.

Template Parameters

A	The type of the first matrix, which should be MxN
B	The type of the second matrix, which should be NxP

Parameters

[in]	a	An MxN matrix of type A
[in]	b	An NxP matrix of type P

Returns

The product ab

Definition at line 78 of file AlgebraHelpers.hpp.

View newest version in sPHENIX GitHub at line 78 of file AlgebraHelpers.hpp

References KFPMath::b, N, P(), and physmon_track_finding_ttbar::r.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE_TEMPLATE().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename track_container_t , typename track_state_container_t , template< typename > class holder_t>

void Acts::calculateTrackQuantities

(

Acts::TrackProxy< track_container_t, track_state_container_t, holder_t, false >

track

)

Helper function to calculate a number of track level quantities and store them on the track itself

Note

The input track needs to be mutable, so ReadOnly=false

Template Parameters

track_container_t	the track container backend
track_state_container_t	the track state container backend
holder_t	the holder type for the track container backends

Parameters

track

A mutable track proxy to operate on

Definition at line 24 of file TrackHelpers.hpp.

View newest version in sPHENIX GitHub at line 24 of file TrackHelpers.hpp

References HoleFlag, MeasurementFlag, OutlierFlag, and SharedHitFlag.

Referenced by BOOST_AUTO_TEST_CASE(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::findTracks(), Acts::Experimental::Gx2Fitter< propagator_t, traj_t >::fit(), Acts::KalmanFitter< propagator_t, traj_t >::fit(), and Acts::GaussianSumFitter< propagator_t, bethe_heitler_approx_t, traj_t >::fit_impl().

Here is the caller graph for this function:

template<typename T , typename U >

T Acts::clampValue

(

U

value

)

Clamp a numeric value to another type, respecting range of the target type

Template Parameters

T	the target type
U	the source type

Parameters

value

the value to clamp

Returns

the clamped value

Definition at line 161 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 161 of file Helpers.hpp

void Acts::collectCompounds_dd4hep	(	dd4hep::DetElement &	detElement,
		std::vector< dd4hep::DetElement > &	compounds
	)

Method internally used by convertDD4hepDetector to collect all volumes of a compound detector

Parameters

[in]	detElement	the dd4hep::DetElement of the volume of which the compounds should be collected
[out]	compounds	the DD4hep::DetElements of the compounds contained by detElement

Definition at line 573 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 573 of file ConvertDD4hepDetector.cpp

References gtest_filter_unittest::child, and type.

Referenced by volumeBuilder_dd4hep().

Here is the caller graph for this function:

void Acts::collectLayers_dd4hep	(	dd4hep::DetElement &	detElement,
		std::vector< dd4hep::DetElement > &	layers,
		const Logger &	logger
	)

Method internally used by convertDD4hepDetector

Parameters

[in]	detElement	the dd4hep::DetElement of the volume of which the layers should be collected
[out]	layers	the DD4hep::DetElements of the layers contained by detElement
	logger	a Logger for output

Definition at line 605 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 605 of file ConvertDD4hepDetector.cpp

References ACTS_VERBOSE(), and gtest_filter_unittest::child.

Referenced by volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::collectSubDetectors_dd4hep	(	dd4hep::DetElement &	detElement,
		std::vector< dd4hep::DetElement > &	subdetectors,
		const Logger &	logger
	)

Method internally used by convertDD4hepDetector to collect all sub detectors Sub detector means each 'compound' DetElement or DetElements which are declared as 'isBarrel' or 'isBeampipe' by their extension.

Parameters

[in]	detElement	the dd4hep::DetElement of the volume of which the sub detectors should be collected
[out]	subdetectors	the DD4hep::DetElements of the sub detectors contained by detElement
	logger	a Logger for output

Definition at line 586 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 586 of file ConvertDD4hepDetector.cpp

References gtest_filter_unittest::child, and type.

Referenced by convertDD4hepDetector().

Here is the caller graph for this function:

float Acts::computeEnergyLossBethe	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes

-dE(x) = -dE/dx * x

where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.

Definition at line 171 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 171 of file Interactions.cpp

References eps, I, Acts::UnitConstants::m, testing::Ne(), thickness, and physmon_ckf_tracking::u.

Referenced by BOOST_DATA_TEST_CASE(), computeEnergyLossMean(), Acts::detail::PointwiseMaterialInteraction::evaluatePointwiseMaterialInteraction(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossLandau	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the most propable energy loss due to ionisation and excitation.

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes

-dE(x) = -dE/dx * x

where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.

This computes the most probable energy loss -dE(x) through a material of the given properties and thickness as described by the mode of the Landau-Vavilov-Bichsel distribution. The computations are valid for intermediate particle energies.

Definition at line 233 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 233 of file Interactions.cpp

References eps, I, Acts::UnitConstants::m, testing::Ne(), thickness, and physmon_ckf_tracking::u.

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), computeEnergyLossMode(), ActsFatras::BetheBloch::operator()(), and Fatras::BetheBloch::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossLandauFwhm	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the full with half maximum of landau energy loss distribution

See Also

computeEnergyLossBethe for parameters description

Definition at line 303 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 303 of file Interactions.cpp

References Acts::UnitConstants::m.

Referenced by BOOST_AUTO_TEST_CASE(), and computeEnergyLossLandauSigmaQOverP().

Here is the caller graph for this function:

float Acts::computeEnergyLossLandauSigma	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the Gaussian-equivalent sigma for the ionisation loss fluctuations.

See Also

computeEnergyLossBethe for parameters description

This is the sigma parameter of a Gaussian distribution with the same full-width-half-maximum as the Landau-Vavilov-Bichsel distribution. The computations are valid for intermediate particle energies.

Definition at line 288 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 288 of file Interactions.cpp

References Acts::UnitConstants::m, testing::Ne(), and thickness.

Referenced by BOOST_DATA_TEST_CASE(), main(), ActsFatras::BetheBloch::operator()(), and Fatras::BetheBloch::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossLandauSigmaQOverP	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute q/p Gaussian-equivalent sigma due to ionisation loss fluctuations.

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes

-dE(x) = -dE/dx * x

where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.

Definition at line 309 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 309 of file Interactions.cpp

References computeEnergyLossLandauFwhm(), and Acts::UnitConstants::m.

Referenced by BOOST_DATA_TEST_CASE(), and Acts::detail::PointwiseMaterialInteraction::covarianceContributions().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossMean	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the combined mean energy loss.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the combined mean energy loss -dE(x) including ionisation and radiative effects. The computations are valid over a wide range of particle energies.

Definition at line 447 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 447 of file Interactions.cpp

References computeEnergyLossBethe(), and computeEnergyLossRadiative().

Referenced by BOOST_DATA_TEST_CASE(), Acts::detail::GenericDenseEnvironmentExtension< scalar_t >::initializeEnergyLoss(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossMode	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the combined most probably energy loss.

Compute the combined mean energy loss.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the combined mean energy loss -dE(x) including ionisation and radiative effects. The computations are valid over a wide range of particle energies.

Definition at line 460 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 460 of file Interactions.cpp

References computeEnergyLossLandau(), and computeEnergyLossRadiative().

Referenced by BOOST_DATA_TEST_CASE(), and Acts::detail::GenericDenseEnvironmentExtension< scalar_t >::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossRadiative	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the mean energy loss due to radiative effects at high energies.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) using an approximative formula. Bremsstrahlung is always included; direct e+e- pair production and photo-nuclear interactions only for muons.

Definition at line 382 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 382 of file Interactions.cpp

References assert, eMuon, energy, makeAbsolutePdgParticle(), momentum, and ambiguity_solver_full_chain::x.

Referenced by BOOST_DATA_TEST_CASE(), computeEnergyLossMean(), computeEnergyLossMode(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeMultipleScatteringTheta0	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Compute the core width of the projected planar scattering distribution.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

Definition at line 500 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 500 of file Interactions.cpp

References assert, eElectron, and makeAbsolutePdgParticle().

Referenced by BOOST_DATA_TEST_CASE(), Acts::detail::PointwiseMaterialInteraction::covarianceContributions(), ActsFatras::detail::Highland::operator()(), Fatras::Highland::operator()(), Fatras::GeneralMixture::operator()(), ActsFatras::detail::GeneralMixture::operator()(), ActsFatras::detail::GaussianMixture::operator()(), and Fatras::GaussianMixture::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

MutableTrackingVolumePtr Acts::constructContainerVolume	(	const GeometryContext &	gctx,
		TrackingVolumePtr	iVolume,
		TrackingVolumePtr	oVolume,
		double	hVolumeR,
		double	hVolumeHalflength,
		const std::string &	name
	)

helper function to create a container

create the volume array

the bounds for the container

create the BinUtility & the BinnedArray

create the container volume

Definition at line 90 of file TrackingVolumeCreation.hpp.

View newest version in sPHENIX GitHub at line 90 of file TrackingVolumeCreation.hpp

References binR, Acts::TrackingVolume::create(), Acts::Test::hVolume, Acts::Test::iVolume, testing::internal::move(), open, Acts::Test::oVolume, and volumes.

Referenced by Acts::Test::makeTrackingGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

TrackingVolumePtr Acts::constructCylinderVolume	(	const GeometryContext &	gctx,
		double	surfaceHalfLengthZ,
		double	surfaceR,
		double	surfaceRstagger,
		double	surfaceZoverlap,
		double	layerEnvelope,
		double	volumeEnvelope,
		double	innerVolumeR,
		double	outerVolumeR,
		const std::string &	name
	)

helper function to create a cylinder

the surface transforms

the surfaces

prepare the surfaces

make the binned array

now create the Layer

create the volume

return the volume

Definition at line 25 of file TrackingVolumeCreation.hpp.

View newest version in sPHENIX GitHub at line 25 of file TrackingVolumeCreation.hpp

References Acts::CylinderLayer::create(), Acts::TrackingVolume::create(), loc, std::tr1::make_tuple(), testing::internal::move(), and perf_headwind::name.

Referenced by Acts::Test::makeTrackingGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<Acts::Experimental::ProtoBinning> Acts::convertBinning	(	const dd4hep::DetElement &	dd4hepElement,
		const std::string &	bname
	)

This method converts the DD4hep binning into the Acts ProtoBinning.

Parameters

dd4hepElement	the element which has a binning description attached
bname	the binning base name, e.g. surface_binning, material_binning

Returns

a vector of proto binning descriptions

Definition at line 119 of file DD4hepBinningHelpers.hpp.

View newest version in sPHENIX GitHub at line 119 of file DD4hepBinningHelpers.hpp

References allowedBinnings, binPhi, edges, add_histos_bX::ib, Acts::UnitConstants::min, to_string(), and type.

Referenced by Acts::DD4hepDetectorSurfaceFactory::recursiveConstruct().

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< const TrackingGeometry > Acts::convertDD4hepDetector	(	dd4hep::DetElement	worldDetElement,
		const Logger &	logger,
		BinningType	bTypePhi = equidistant,
		BinningType	bTypeR = equidistant,
		BinningType	bTypeZ = equidistant,
		double	layerEnvelopeR = UnitConstants::mm,
		double	layerEnvelopeZ = UnitConstants::mm,
		double	defaultLayerThickness = UnitConstants::fm,
		const std::function< void(std::vector< dd4hep::DetElement > &detectors)> &	sortSubDetectors = sortDetElementsByID,
		const GeometryContext &	gctx = GeometryContext(),
		std::shared_ptr< const IMaterialDecorator >	matDecorator = nullptr,
		std::shared_ptr< const GeometryIdentifierHook >	geometryIdentifierHook = std::make_shared<GeometryIdentifierHook>()
	)

Global method which creates the TrackingGeometry from DD4hep input.

This method returns a std::unique_ptr of the TrackingGeometry from the World DD4hep DetElement.

Precondition

Before using this method make sure, that the preconditions described in DD4hepPlugins are met.

Parameters

[in]	worldDetElement	the DD4hep DetElement of the world
[in]	logger	A logger instance geometry building
[in]	bTypePhi	is how the sensitive surfaces (modules) should be binned in a layer in phi direction.

Note

Possible binningtypes:

• arbitrary - of the sizes if the surfaces and the distance in between vary. This mode finds out the bin boundaries by scanning through the surfaces.
• equidistant - if the sensitive surfaces are placed equidistantly

equidistant binningtype is recommended because it is faster not only while building the geometry but also for look up during the extrapolation

Parameters

[in]	bTypeR	is how the sensitive surfaces (modules) should be binned in a layer in r direction
[in]	bTypeZ	is how the sensitive surfaces (modules) should be binned in a layer in z direction
[in]	layerEnvelopeR	the tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
[in]	layerEnvelopeZ	the tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
[in]	defaultLayerThickness	In case no surfaces (to be contained by the layer) are handed over, the layer thickness will be set to this value

Note

Layers containing surfaces per default are not allowed to be attached to each other (navigation will fail at this point). However, to allow material layers (not containing surfaces) to be attached to each other, this default thickness is needed. In this way, the layer will be thin (with space to the next layer), but the material will have the 'real' thickness.

Attention

The default thickness should be set thin enough that no touching or overlapping with the next layer can happen.

Parameters

[in]	sortSubDetectors	std::function which should be used in order to sort all sub detectors (=all Detelements collected by the method collectSubDetectors() ) from bottom to top to ensure correct wrapping of the volumes, which is needed for navigation. Therefore the different hierarchies need to be sorted ascending. The default is sorting by ID.
	gctx	The geometry context to use
	matDecorator	is the material decorator that loads material maps
	geometryIdentifierHook	Hook to apply to surfaces during geometry closure.

Exceptions

std::logic_error

if an error in the translation occurs

Returns

std::unique_ptr to the full TrackingGeometry * The Tracking geometry needs to be built from bottom to top to ensure Navigation. Therefore the different hierarchies need to be sorted ascending. Per default the sub detectors are sorted by the id of their dd4hep::DetElement. In case another sorting needs to be applied, the users can provide their own function

Definition at line 61 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 61 of file ConvertDD4hepDetector.cpp

References ACTS_INFO, ACTS_VERBOSE(), collectSubDetectors_dd4hep(), cylinderVolumeHelper_dd4hep(), Acts::TrackingGeometryBuilder::Config::geometryIdentifierHook, k, Acts::TrackingGeometryBuilder::Config::materialDecorator, testing::internal::move(), Acts::TrackingGeometryBuilder::Config::trackingVolumeBuilders, Acts::TrackingGeometryBuilder::Config::trackingVolumeHelper, testSigmaEff::v, and volumeBuilder_dd4hep().

Here is the call graph for this function:

Acts::Grid2D Acts::createGrid	(	Acts::MaterialGridAxisData	gridAxis1,
		Acts::MaterialGridAxisData	gridAxis2
	)

Helper method that creates the cache grid for the mapping. This grid allows the collection of material at a the anchor points.

Parameters

[in]	gridAxis1	Axis data
[in]	gridAxis2	Axis data

Note

The data of the axes is given in the std::array as {minimum value, maximum value, number of bins}

Returns

The grid

Definition at line 21 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 21 of file MaterialGridHelper.cpp

References std::tr1::make_tuple(), and testing::internal::move().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), createGrid2D(), and createGrid3D().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::Grid3D Acts::createGrid	(	Acts::MaterialGridAxisData	gridAxis1,
		Acts::MaterialGridAxisData	gridAxis2,
		Acts::MaterialGridAxisData	gridAxis3
	)

Helper method that creates the cache grid for the mapping. This grid allows the collection of material at a the anchor points.

Parameters

[in]	gridAxis1	Axis data
[in]	gridAxis2	Axis data
[in]	gridAxis3	Axis data

Note

The data of the axes is given in the std::array as {minimum value, maximum value, number of bins}

Returns

The grid

Definition at line 48 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 48 of file MaterialGridHelper.cpp

References std::tr1::make_tuple(), and testing::internal::move().

Here is the call graph for this function:

Acts::Grid2D Acts::createGrid2D	(	const BinUtility &	bins,
		std::function< Acts::Vector2(Acts::Vector3)> &	transfoGlobalToLocal
	)

Create a 2DGrid using a BinUtility. Also determine the corresponding global to local transform and grid mapping function.

Parameters

[in]	bins	BinUtility of the volume to be mapped
[in]	transfoGlobalToLocal	Global to local transform to be updated.

Returns

the 3D grid

Definition at line 132 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 132 of file MaterialGridHelper.cpp

References KFPMath::b, Acts::BinUtility::binningData(), binPhi, binR, binX, binY, createGrid(), globalToLocalFromBin(), Acts::Test::pos, and Acts::BinUtility::transform().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::VolumeMaterialMapper::checkAndInsert(), from_json(), and while().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::Grid3D Acts::createGrid3D	(	const BinUtility &	bins,
		std::function< Acts::Vector3(Acts::Vector3)> &	transfoGlobalToLocal
	)

Create a 3DGrid using a BinUtility. Also determine the corresponding global to local transform and grid mapping function.

Parameters

[in]	bins	BinUtility of the volume to be mapped
[in]	transfoGlobalToLocal	Global to local transform to be updated.

Returns

the 3D grid

Definition at line 169 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 169 of file MaterialGridHelper.cpp

References KFPMath::b, Acts::BinUtility::binningData(), binPhi, binR, binX, binY, createGrid(), globalToLocalFromBin(), Acts::Test::pos, and Acts::BinUtility::transform().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::VolumeMaterialMapper::checkAndInsert(), from_json(), and while().

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Acts::ProtoSurfaceMaterial > Acts::createProtoMaterial	(	const dd4hep::rec::VariantParameters &	params,
		const std::string &	valueTag,
		const std::vector< std::pair< const std::string, Acts::BinningOption > > &	binning,
		const Logger &	logger = getDummyLogger()
	)

Helper method to create proto material - to be called from the addProto(...) methods

Parameters

params	An instance of DD4hep::VariantParameters
valueTag	the xml tag for to ActsExtension to be parsed
binning	the Binning prescription for the ActsExtension
logger	a Logger for output

Definition at line 26 of file DD4hepMaterialConverter.cpp.

View newest version in sPHENIX GitHub at line 26 of file DD4hepMaterialConverter.cpp

References ACTS_VERBOSE, parse_cmake_options::begin, binningValueNames(), bins, closed, distance(), end, Acts::UnitConstants::min, and physmon_simulation::s.

Referenced by addLayerProtoMaterial(), and volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< const Acts::CylinderVolumeHelper > Acts::cylinderVolumeHelper_dd4hep

(

const Logger &

logger

)

Helper method internally used to create a default Acts::CylinderVolumeBuilder

Definition at line 550 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 550 of file ConvertDD4hepDetector.cpp

References Acts::Logger::clone(), and Acts::CylinderVolumeHelper::Config::layerArrayCreator.

Referenced by convertDD4hepDetector(), and volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename track_container_t , typename traj_t , template< typename > class holder_t>

std::unordered_map<int, std::vector<int> > Acts::dbscanTrackClustering	(	std::multimap< int, std::pair< int, std::vector< int >>> &	trackMap,
		const Acts::TrackContainer< track_container_t, traj_t, holder_t > &	tracks,
		float	epsilon = 0.07,
		int	minPoints = 2
	)

Clusterise tracks based on shared hits

Parameters

trackMap	: Multimap storing pair of track ID and vector of measurement ID. The keys are the number of measurement and are just there to facilitate the ordering.
tracks	: Track container with all the track to be clustered
epsilon	: Maximum distance between 2 tracks to be clustered
minPoints	: Minimum number of tracks to create a cluster

Returns

an unordered map representing the clusters, the keys the ID of the primary track of each cluster and the store a vector of track IDs.

Definition at line 31 of file AmbiguityDBScanClustering.hpp.

View newest version in sPHENIX GitHub at line 31 of file AmbiguityDBScanClustering.hpp

References Acts::detail::clusterDuplicateTracks(), configureMap::data, Acts::VectorHelpers::eta(), Acts::VectorHelpers::phi(), and trackID.

Referenced by ActsExamples::AmbiguityResolutionMLDBScanAlgorithm::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::decodeBinning	(	dd4hep::rec::VariantParameters &	variantParams,
		const xml_comp_t &	xmlBinning,
		const std::string &	bname,
		const std::vector< std::string > &	bvals
	)

Helper method to decode the binning from what would appear in the xml into variant parameters, such that it can be understood in the downstream processing.

This parses the dediced < surface_binning > tag

• allowed/understood binnings are x,y,z,phi,r
• allowed/unserstood types are equidistant/variable (those are auto-detected)

Example for e.g. bname = "surface_binning":

• Equidistant binning in r and phi: < surface_binning nr="2" rmin="25" rmax="100" nphi="22" phimin="-3.1415" phimax="3.1415" \/ >
• Variable binning in z: < surface_binning zboundaries="-100,-90,90,100" \/ >

And 2D combinations of this are allowed.

Parameters

variantParams	[in,out] the variant parameters that will be overwritten
xmlBinning	the surface binning
bname	the binning base name, e.g. surface_binning, material_binning
bvals	the boundary values, i.e. x,y,z,phi,r

Definition at line 57 of file DD4hepBinningHelpers.hpp.

View newest version in sPHENIX GitHub at line 57 of file DD4hepBinningHelpers.hpp

References end, add_histos_bX::ib, Acts::UnitConstants::mm, and to_string().

Referenced by addCylinderLayer(), and create_disc_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class decorator_t >

void Acts::decorateJson	(	[[maybe_unused] ] const decorator_t *	decorator,
		[[maybe_unused] ] const T &	src,
		[[maybe_unused] ] nlohmann::json &	dest
	)

Definition at line 126 of file GeometryHierarchyMapJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 126 of file GeometryHierarchyMapJsonConverter.hpp

Referenced by Acts::GeometryHierarchyMapJsonConverter< value_t, decorator_t >::toJson().

Here is the caller graph for this function:

template<class T , class decorator_t >

void Acts::decorateJson	(	[[maybe_unused] ] const decorator_t *	decorator,
		[[maybe_unused] ] const T *	src,
		[[maybe_unused] ] nlohmann::json &	dest
	)

Definition at line 135 of file GeometryHierarchyMapJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 135 of file GeometryHierarchyMapJsonConverter.hpp

template<>

void Acts::decorateJson< Acts::ISurfaceMaterial > ( const IVolumeMaterialJsonDecorator *  decorator, const Acts::ISurfaceMaterial *  src, nlohmann::json &  dest  )

inline

Definition at line 79 of file MaterialMapJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 79 of file MaterialMapJsonConverter.cpp

References upload::dest.

template<>

void Acts::decorateJson< Acts::IVolumeMaterial > ( const IVolumeMaterialJsonDecorator *  decorator, const Acts::IVolumeMaterial *  src, nlohmann::json &  dest  )

inline

Definition at line 71 of file MaterialMapJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 71 of file MaterialMapJsonConverter.cpp

References upload::dest.

template<>

void Acts::decorateJson< Acts::SurfaceAndMaterialWithContext > ( const ITrackingGeometryJsonDecorator *  decorator, const Acts::SurfaceAndMaterialWithContext &  src, nlohmann::json &  dest  )

inline

Definition at line 54 of file MaterialMapJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 54 of file MaterialMapJsonConverter.cpp

References upload::dest.

template<>

void Acts::decorateJson< Acts::TrackingVolumeAndMaterial > ( const ITrackingGeometryJsonDecorator *  decorator, const Acts::TrackingVolumeAndMaterial &  src, nlohmann::json &  dest  )

inline

Definition at line 62 of file MaterialMapJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 62 of file MaterialMapJsonConverter.cpp

References upload::dest.

float Acts::deriveEnergyLossBetheQOverP	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Derivative of the Bethe energy loss with respect to q/p.

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes

-dE(x) = -dE/dx * x

where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.

Definition at line 196 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 196 of file Interactions.cpp

References eps, f, I, Acts::UnitConstants::m, testing::Ne(), thickness, and physmon_ckf_tracking::u.

Referenced by deriveEnergyLossMeanQOverP().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossLandauQOverP	(	const MaterialSlab &	slab,
		float	m,
		float	qOverP,
		float	absQ
	)

Derivative of the most probable ionisation energy loss with respect to q/p.

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes

-dE(x) = -dE/dx * x

where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.

Definition at line 253 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 253 of file Interactions.cpp

References eps, I, Acts::UnitConstants::m, testing::Ne(), t, and thickness.

Referenced by deriveEnergyLossModeQOverP().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossMeanQOverP	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Derivative of the combined mean energy loss with respect to q/p.

Compute the combined mean energy loss.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the combined mean energy loss -dE(x) including ionisation and radiative effects. The computations are valid over a wide range of particle energies.

Definition at line 453 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 453 of file Interactions.cpp

References deriveEnergyLossBetheQOverP(), and deriveEnergyLossRadiativeQOverP().

Referenced by Acts::detail::GenericDenseEnvironmentExtension< scalar_t >::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossModeQOverP	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Derivative of the combined most probable energy loss with respect to q/p.

Compute the combined mean energy loss.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the combined mean energy loss -dE(x) including ionisation and radiative effects. The computations are valid over a wide range of particle energies.

Definition at line 468 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 468 of file Interactions.cpp

References deriveEnergyLossLandauQOverP(), and deriveEnergyLossRadiativeQOverP().

Referenced by Acts::detail::GenericDenseEnvironmentExtension< scalar_t >::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossRadiativeQOverP	(	const MaterialSlab &	slab,
		PdgParticle	absPdg,
		float	m,
		float	qOverP,
		float	absQ
	)

Derivative of the mean radiative energy loss with respect to q/p.

Compute the mean energy loss due to radiative effects at high energies.

Parameters

slab	The traversed material and its properties
absPdg	Absolute particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
absQ	Absolute particle charge

This computes the mean energy loss -dE(x) using an approximative formula. Bremsstrahlung is always included; direct e+e- pair production and photo-nuclear interactions only for muons.

Definition at line 411 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 411 of file Interactions.cpp

References assert, eMuon, energy, makeAbsolutePdgParticle(), momentum, and ambiguity_solver_full_chain::x.

Referenced by deriveEnergyLossMeanQOverP(), and deriveEnergyLossModeQOverP().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename container_type , typename container_type_iter = decltype(std::begin(std::declval<container_type>())), typename = decltype(std::end(std::declval<container_type>()))>

constexpr auto Acts::enumerate

(

container_type &&

iterable

)

Helper utility to allow indexed enumeration with structured binding

Usage:

for (auto [ i, value ] = enumerate(container) ) { ... };

with 'container' any stl-like container

Increase index and iterator at once

Tie them together for returning

Definition at line 27 of file Enumerate.hpp.

View newest version in sPHENIX GitHub at line 27 of file Enumerate.hpp

References parse_cmake_options::begin, end, i, operator!=(), operator*(), and check_smearing_config::rhs.

Referenced by cpp.ast.AstBuilder::_GenerateOne(), acts.examples.Sequencer::_getAutoFpeMasks(), acts.examples.Sequencer::_printFpeSummary(), SurfaceGeoIdGenerator::assignGeometryId(), BOOST_AUTO_TEST_CASE(), check_fpe_masks::check(), Acts::Experimental::DetectorVolume::closePortals(), check_include_guards::code_print(), CompBuilder::construct(), CylindricalVolumeBuilder< surface_type, surface_bounds_type >::construct(), Acts::Experimental::DetectorVolumeBuilder::construct(), global-time-converter::convert(), Acts::Svg::DetectorConverter::convert(), Acts::Svg::DetectorVolumeConverter::convert(), Acts::Svg::IndexedSurfacesConverter::convertImpl(), cpp.ast.TypeConverter::DeclarationToParts(), Acts::Experimental::Detector::Detector(), INTTVtxZ::Draw_1DEffComp(), plot_DataSimComp::Draw_1Dhist_datasimcomp(), centProxy::Draw_1Dhist_wPercentile(), plotUtil::Draw_1DhistsComp(), centProxy::Draw_2Dhist_wPercentile(), ActsExamples::HoughTransformSeeder::execute(), from_json(), Acts::DetectorJsonConverter::fromJson(), Acts::PortalJsonConverter::fromJson(), generate_particle_data_table::generate_code(), Acts::Experimental::generatePortals(), check_license::main(), RecoPV_optimization::main(), acts.examples::NamedTypeArgs(), Acts::Experimental::detail::IndexedSurfacesGenerator< surface_container, indexed_updator >::operator()(), Acts::Experimental::detail::outputIndices(), parse_clang_tidy::parse_clang_tidy_output(), plotUtil::plot_Stack(), Acts::Extent::range(), Acts::Experimental::KdtSurfaces< kDIM, bSize, reference_generator >::surfaces(), to_array(), to_json(), Acts::DetectorVolumeJsonConverter::toJsonDetray(), Acts::PortalJsonConverter::toJsonDetray(), Acts::BinUtility::toStream(), and Acts::Svg::View::xy().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename spacepoint_iterator_t >

std::optional<BoundVector> Acts::estimateTrackParamsFromSeed	(	spacepoint_iterator_t	spBegin,
		spacepoint_iterator_t	spEnd,
		const Logger &	logger = getDummyLogger()
	)

Estimate the track parameters on the xy plane from at least three space points. It assumes the trajectory projection on the xy plane is a circle, i.e. the magnetic field is along global z-axis.

The method is based on V. Karimaki NIM A305 (1991) 187-191: https://doi.org/10.1016/0168-9002(91)90533-V

• no weights are used in Karimaki's fit; d0 is the distance of the point of closest approach to the origin, 1/R is the curvature, phi is the angle of the direction propagation (counter clockwise as positive) at the point of cloest approach.

Template Parameters

spacepoint_iterator_t

The type of space point iterator

Parameters

spBegin	is the begin iterator for the space points
spEnd	is the end iterator for the space points
logger	A logger instance

Returns

optional bound track parameters with the estimated d0, phi and 1/R stored with the indices, eBoundLoc0, eBoundPhi and eBoundQOverP, respectively. The bound parameters with other indices are set to zero.

Definition at line 52 of file EstimateTrackParamsFromSeed.hpp.

View newest version in sPHENIX GitHub at line 52 of file EstimateTrackParamsFromSeed.hpp

References ACTS_ERROR, physmon_vertexing::delta, distance(), eBoundLoc0, eBoundPhi, eBoundQOverP, it, k, ActsTests::PropagationDatasets::phi, r2, rho, ambiguity_solver_full_chain::x, and y.

Referenced by BOOST_AUTO_TEST_CASE(), ActsExamples::PrototracksToParameters::execute(), and ActsExamples::TrackParamsEstimationAlgorithm::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename spacepoint_iterator_t >

std::optional<BoundVector> Acts::estimateTrackParamsFromSeed	(	const GeometryContext &	gctx,
		spacepoint_iterator_t	spBegin,
		spacepoint_iterator_t	spEnd,
		const Surface &	surface,
		const Vector3 &	bField,
		ActsScalar	bFieldMin,
		const Acts::Logger &	logger = getDummyLogger(),
		ActsScalar	mass = 139.57018 * UnitConstants::MeV
	)

Estimate the full track parameters from three space points

This method is based on the conformal map transformation. It estimates the full bound track parameters, i.e. (loc0, loc1, phi, theta, q/p, t) at the bottom space point. The bottom space is assumed to be the first element in the range defined by the iterators. It must lie on the surface provided for the representation of the bound track parameters. The magnetic field (which might be along any direction) is also necessary for the momentum estimation.

It resembles the method used in ATLAS for the track parameters estimated from seed, i.e. the function InDet::SiTrackMaker_xk::getAtaPlane here: https://acode-browser.usatlas.bnl.gov/lxr/source/athena/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx

Template Parameters

spacepoint_iterator_t

The type of space point iterator

Parameters

gctx	is the geometry context
spBegin	is the begin iterator for the space points
spEnd	is the end iterator for the space points
surface	is the surface of the bottom space point. The estimated bound track parameters will be represented also at this surface
bField	is the magnetic field vector
bFieldMin	is the minimum magnetic field required to trigger the estimation of q/pt
logger	A logger instance
mass	is the estimated particle mass

Returns

optional bound parameters

Definition at line 155 of file EstimateTrackParamsFromSeed.hpp.

View newest version in sPHENIX GitHub at line 155 of file EstimateTrackParamsFromSeed.hpp

References A, ACTS_ERROR, ACTS_WARNING, distance(), eBoundLoc0, eBoundLoc1, eBoundPhi, eBoundQOverP, eBoundTheta, eBoundTime, G, Acts::UnitConstants::GeV, Acts::Surface::globalToLocal(), it, Acts::UnitConstants::m, mass, next, Acts::VectorHelpers::phi(), rho, Acts::UnitConstants::T, Acts::VectorHelpers::theta(), Acts::Test::transform, testSigmaEff::v, and vz.

Here is the call graph for this function:

template<typename value_type >

std::vector<value_type> Acts::extractSeries	(	const dd4hep::DetElement &	dd4hepElement,
		const std::string &	bname,
		const value_type &	unitConversion = 1
	)

A simple helper function to extract a series.

Template Parameters

value_type

the primitive type allowed by variant parameters

Parameters

dd4hepElement	the detector element with associated variant parameters
bname	The base name attribute of the variant parameter pack
unitConversion	is a conversion factor DD4hep -> ACTS

Returns

the extracted series as a vector

Definition at line 129 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 129 of file DD4hepConversionHelpers.hpp

References add_histos_bX::ib, series(), and to_string().

Here is the call graph for this function:

Transform3 Acts::extractTransform ( const dd4hep::DetElement &  dd4hepElement, const std::string &  bname, const ActsScalar  unitConversion = 1.  )

inline

A simple helper function to extract a transform.

Parameters

dd4hepElement	the detector element with associated variant parameters
bname	The base name attribute of the variant parameter pack
unitConversion	is a conversion factor DD4hep -> ACTS

Returns

a transform extracted from parameters

Definition at line 153 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 153 of file DD4hepConversionHelpers.hpp

References Acts::Test::transform, ambiguity_solver_full_chain::x, y, and physmon_track_finding_ttbar::z.

Referenced by Acts::Experimental::DD4hepVolumeStructure::recursiveParse().

Here is the caller graph for this function:

Acts::InterpolatedBFieldMap< Acts::detail::Grid< Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::fieldMapRZ	(	const std::function< size_t(std::array< size_t, 2 > binsRZ, std::array< size_t, 2 > nBinsRZ)> &	localToGlobalBin,
		std::vector< double >	rPos,
		std::vector< double >	zPos,
		std::vector< Acts::Vector2 >	bField,
		double	lengthUnit = UnitConstants::mm,
		double	BFieldUnit = UnitConstants::T,
		bool	firstQuadrant = false
	)

Method to setup the FieldMap

Parameters

localToGlobalBin

Function mapping the local bins of r,z to the global bin of the map magnetic field value

e.g.: we have small grid with the values: r={2,3}, z ={4,5}, the corresponding indices are i (belonging to r) and j (belonging to z), the globalIndex is M (belonging to the value of the magnetic field B(r,z)) and the field map is:

r	i	z	j	B(r,z)	M
2	0	4	0	2.323	0
2	0	5	1	2.334	1
3	1	4	0	2.325	2
3	1	5	1	2.331	3

In this case the function would look like:

[](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) {
   return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1));
}

Parameters

[in]

rPos

Values of the grid points in r

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

zPos

Values of the grid points in z

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

bField

The magnetic field values inr r and z for all given grid points stored in a vector

Note

The function localToGlobalBin determines how the magnetic field was stored in the vector in respect to the grid values

Parameters

[in]	lengthUnit	The unit of the grid points
[in]	BFieldUnit	The unit of the magnetic field
[in]	firstQuadrant	Flag if set to true indicating that only the first quadrant of the grid points and the BField values has been given.

Note

If firstQuadrant is true will create a field that is symmetric for all quadrants. e.g. we have the grid values r={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the r-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.

Returns

A field map instance for use in interpolation.

Definition at line 33 of file BFieldMapUtils.cpp.

View newest version in sPHENIX GitHub at line 33 of file BFieldMapUtils.cpp

References ckf::field, grid(), i, j, std::tr1::make_tuple(), Acts::UnitConstants::min, testing::internal::move(), n, Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), Acts::Test::pos, and Acts::Experimental::detail::BlueprintHelper::sort().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), ActsExamples::makeMagneticFieldMapRzFromRoot(), and ActsExamples::makeMagneticFieldMapRzFromText().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::InterpolatedBFieldMap< Acts::detail::Grid< Acts::Vector3, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::fieldMapXYZ	(	const std::function< size_t(std::array< size_t, 3 > binsXYZ, std::array< size_t, 3 > nBinsXYZ)> &	localToGlobalBin,
		std::vector< double >	xPos,
		std::vector< double >	yPos,
		std::vector< double >	zPos,
		std::vector< Acts::Vector3 >	bField,
		double	lengthUnit = UnitConstants::mm,
		double	BFieldUnit = UnitConstants::T,
		bool	firstOctant = false
	)

Method to setup the FieldMap

Parameters

localToGlobalBin

Function mapping the local bins of x,y,z to the global bin of the map magnetic field value

e.g.: we have small grid with the values: x={2,3}, y={3,4}, z ={4,5}, the corresponding indices are i (belonging to x), j (belonging to y) and k (belonging to z), the globalIndex is M (belonging to the value of the magnetic field B(x,y,z)) and the field map is:

x	i	y	j	z	k	B(x,y,z)	M
2	0	3	0	4	0	2.323	0
2	0	3	0	5	1	2.334	1
2	0	4	1	4	0	2.325	2
2	0	4	1	5	1	2.331	3
3	1	3	0	4	0	2.323	4
3	1	3	0	5	1	2.334	5
3	1	4	1	4	0	2.325	6
3	1	4	1	5	1	2.331	7

In this case the function would look like:

[](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) {
  return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2))
       + binsXYZ.at(1) * nBinsXYZ.at(2)
       + binsXYZ.at(2));
}

Note

The grid point values xPos, yPos and zPos do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]	xPos	Values of the grid points in x
[in]	yPos	Values of the grid points in y
[in]	zPos	Values of the grid points in z
[in]	bField	The magnetic field values inr r and z for all given grid points stored in a vector

Note

The function localToGlobalBin determines how the magnetic field was stored in the vector in respect to the grid values

Parameters

[in]	lengthUnit	The unit of the grid points
[in]	BFieldUnit	The unit of the magnetic field
[in]	firstOctant	Flag if set to true indicating that only the first octant of the grid points and the BField values has been given.

Note

If firstOctant is true, the function will assume a symmetrical field for all quadrants. e.g. we have the grid values z={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the z-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.

Returns

A field map instance for use in interpolation.

Definition at line 140 of file BFieldMapUtils.cpp.

View newest version in sPHENIX GitHub at line 140 of file BFieldMapUtils.cpp

References ckf::field, grid(), i, j, k, Acts::UnitConstants::m, std::tr1::make_tuple(), testing::internal::move(), n, Acts::IntegrationTest::nBinsZ, Acts::Test::pos, and Acts::Experimental::detail::BlueprintHelper::sort().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), ActsExamples::makeMagneticFieldMapXyzFromRoot(), and ActsExamples::makeMagneticFieldMapXyzFromText().

Here is the call graph for this function:

Here is the caller graph for this function:

std::optional< float > Acts::findCharge

(

Acts::PdgParticle

pdg

)

Find the charge for a given PDG particle number.

Returns

Charge in native units.

Definition at line 65 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 65 of file ParticleData.cpp

References charge(), and kParticlesThreeCharge.

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), ActsExamples::HepMC3Particle::charge(), main(), and ActsExamples::HepMC3Particle::particle().

Here is the call graph for this function:

Here is the caller graph for this function:

std::optional< float > Acts::findMass

(

Acts::PdgParticle

pdg

)

Find the mass for a given PDG particle number.

Returns

Mass in native units.

Definition at line 74 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 74 of file ParticleData.cpp

References kParticlesMassMeV, and mass.

Referenced by BOOST_AUTO_TEST_CASE(), and main().

Here is the caller graph for this function:

std::optional< std::string_view > Acts::findName

(

Acts::PdgParticle

pdg

)

Find a descriptive particle name for a given PDG particle number.

Returns

Particle name.

Definition at line 83 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 83 of file ParticleData.cpp

References kParticlesName.

Referenced by BOOST_AUTO_TEST_CASE(), main(), and operator<<().

Here is the caller graph for this function:

std::optional< Acts::ParticleData > Acts::findParticleData

(

PdgParticle

pdg

)

Find all known particle data for a given PDG particle number.

Returns

Particle name.

Definition at line 87 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 87 of file ParticleData.cpp

References Acts::ParticleData::charge, index, kParticlesMassMeV, kParticlesName, kParticlesThreeCharge, Acts::ParticleData::mass, and Acts::ParticleData::name.

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::Transform3 &	t
	)

Definition at line 36 of file AlgebraJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 36 of file AlgebraJsonConverter.cpp

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::Extent &	e
	)

Definition at line 51 of file ExtentJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 51 of file ExtentJsonConverter.cpp

References binningValueNames(), enumerate(), add_histos_bX::ib, Acts::Extent::set(), and Acts::Extent::setEnvelope().

Here is the call graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::ProtoVolume &	pv
	)

Helper method to read binnings

Parameters

root	is the json root
binning	is the vector of binning data to be filled
key	is the lookup key

Definition at line 68 of file ProtoDetectorJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 68 of file ProtoDetectorJsonConverter.cpp

References Acts::ProtoVolume::container, Acts::ProtoVolume::extent, Acts::ProtoVolume::internal, Acts::ProtoVolume::name, and fixGDML::root.

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::TGeoCylinderDiscSplitter::Config &	cdc
	)

Read config for cylinder/disc module splitter.

Number of segments in phi for a disc

Number of segments in r for a disk

Number of segments in phi for a disc

Number of segments in r for a disk

Definition at line 25 of file JsonTGeoDetectorConfig.hpp.

View newest version in sPHENIX GitHub at line 25 of file JsonTGeoDetectorConfig.hpp

References Acts::TGeoCylinderDiscSplitter::Config::cylinderLongitudinalSegments, Acts::TGeoCylinderDiscSplitter::Config::cylinderPhiSegments, Acts::TGeoCylinderDiscSplitter::Config::discPhiSegments, and Acts::TGeoCylinderDiscSplitter::Config::discRadialSegments.

Referenced by BOOST_AUTO_TEST_CASE(), ActsExamples::from_json(), from_json(), Acts::Transform3JsonConverter::fromJson(), Acts::SurfaceJsonConverter::fromJson(), and ActsExamples::readJsonGeometryList().

Here is the caller graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		BinningData &	bd
	)

Definition at line 52 of file UtilitiesJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 52 of file UtilitiesJsonConverter.cpp

References arbitrary, bins, closed, equidistant, Acts::UnitConstants::min, testing::internal::move(), and open.

Here is the call graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::ProtoDetector &	pd
	)

Definition at line 122 of file ProtoDetectorJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 122 of file ProtoDetectorJsonConverter.cpp

References Acts::ProtoDetector::name, and Acts::ProtoDetector::worldVolume.

void Acts::from_json	(	const nlohmann::json &	j,
		Material &	t
	)

Definition at line 46 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 46 of file MaterialJsonConverter.cpp

References i.

void Acts::from_json	(	const nlohmann::json &	j,
		Acts::BinUtility &	bu
	)

Definition at line 94 of file UtilitiesJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 94 of file UtilitiesJsonConverter.cpp

References from_json(), and Acts::Transform3JsonConverter::fromJson().

Here is the call graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		MaterialSlab &	t
	)

Definition at line 66 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 66 of file MaterialJsonConverter.cpp

void Acts::from_json	(	const nlohmann::json &	j,
		MaterialSlabMatrix &	t
	)

Definition at line 71 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 71 of file MaterialJsonConverter.cpp

References testing::internal::move().

Here is the call graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		volumeMaterialPointer &	material
	)

Definition at line 291 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 291 of file MaterialJsonConverter.cpp

References Acts::detail::Grid< T, Axes >::at(), Acts::jsonKey::binkey, createGrid2D(), createGrid3D(), Acts::BinUtility::dimensions(), from_json(), std::tr1::make_tuple(), Acts::jsonKey::materialkey, Acts::detail::Grid< T, Axes >::maxPosition(), Acts::UnitConstants::min, Acts::detail::Grid< T, Axes >::minPosition(), testing::internal::move(), Acts::detail::Grid< T, Axes >::numLocalBins(), and value.

Here is the call graph for this function:

template<typename Type >

void Acts::from_json	(	const nlohmann::json &	j,
		Range1D< Type > &	r
	)

Definition at line 41 of file UtilitiesJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 41 of file UtilitiesJsonConverter.hpp

References Acts::Range1D< Type >::setMax(), and Acts::Range1D< Type >::setMin().

Here is the call graph for this function:

void Acts::from_json	(	const nlohmann::json &	j,
		surfaceMaterialPointer &	material
	)

Definition at line 165 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 165 of file MaterialJsonConverter.cpp

References Acts::jsonKey::binkey, Acts::BinUtility::bins(), Default, from_json(), Acts::jsonKey::materialkey, and value.

Here is the call graph for this function:

template<typename value_type >

value_type Acts::getAttrValueOr	(	const dd4hep::xml::Component &	node,
		const std::string &	attrName,
		const value_type &	fallbackValue
	)

Helper method to get an attribute with fallback.

Note

the fallback value has to be provided

Template Parameters

value_type

the primitive type allowed by variant parameters

Parameters

node	the node object from DD4hep
attrName	the name of the attribute that is checked
fallbackValue	the fallbackValue

Returns

either the gathered attribute or the fallback

Definition at line 109 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 109 of file DD4hepConversionHelpers.hpp

std::unique_ptr< const Logger > Acts::getDefaultLogger	(	const std::string &	name,
		const Logging::Level &	lvl,
		std::ostream *	log_stream = &std::cout
	)

get default debug output logger

Parameters

[in]	name	name of the logger instance
[in]	lvl	debug threshold level
[in]	log_stream	output stream used for printing debug messages

This function returns a pointer to a Logger instance with the following decorations enabled:

• time stamps
• name of logging instance
• debug level

Returns

pointer to logging instance

Definition at line 99 of file Logger.cpp.

View newest version in sPHENIX GitHub at line 99 of file Logger.cpp

References testing::internal::move(), perf_headwind::name, check_smearing_config::output, and print().

Referenced by Acts::Python::addDigitization(), Acts::Python::addExaTrkXTrackFinding(), Acts::Python::addExperimentalGeometry(), Acts::Python::addFramework(), Acts::Python::addMaterial(), Acts::Python::addOutput(), Acts::Python::addPropagation(), Acts::Python::addTrackFinding(), Acts::Python::addTrackFitting(), Acts::Test::Layers::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), BOOST_DATA_TEST_CASE(), ActsExamples::Generic::buildDetector(), Acts::Experimental::DD4hepVolumeStructure::builder(), Acts::Experimental::DD4hepLayerStructure::builder(), Acts::CuboidVolumeBuilder::buildVolume(), Acts::Experimental::detail::CylindricalDetectorHelper::connectInR(), Acts::Experimental::detail::CylindricalDetectorHelper::connectInZ(), Acts::Experimental::MultiWireStructureBuilder::construct(), Acts::Sycl::createSeedsForGroupSycl(), ActsExamples::CsvSpacePointReader::CsvSpacePointReader(), Acts::Experimental::CylindricalContainerBuilder::CylindricalContainerBuilder(), ActsExamples::DD4hep::DD4hepGeometryService::DD4hepGeometryService(), ActsExamples::determineEventFilesRange(), ActsExamples::Contextual::AlignedDetector::finalize(), ActsExamples::TGeoDetector::finalize(), PHActsVertexFinder::findVertices(), PHActsInitialVertexFinder::findVertices(), PHActsVertexFitter::fitVertex(), ActsExamples::Geant4SimulationBase::Geant4SimulationBase(), PHActsTrkFitter::InitRun(), Acts::JsonMaterialDecorator::JsonMaterialDecorator(), ActsExamples::JsonMaterialWriter::JsonMaterialWriter(), Acts::Test::LayerCreatorFixture::LayerCreatorFixture(), PHCosmicsTrkFitter::loopTracks(), PHActsTrkFitter::loopTracks(), m_cfg(), main(), ActsPropagator::makeFastPropagator(), ActsPropagator::makePropagator(), Acts::MappingMaterialDecorator::MappingMaterialDecorator(), Acts::MaterialMapJsonConverter::MaterialMapJsonConverter(), Acts::Test::CubicTrackingGeometry::operator()(), Acts::Test::CylindricalTrackingGeometry::operator()(), PHActsGSF::process_event(), processGeometry(), PYBIND11_MODULE(), ActsExamples::Options::readMagneticField(), ActsExamples::RootMaterialDecorator::RootMaterialDecorator(), ActsExamples::RootMaterialTrackReader::RootMaterialTrackReader(), ActsExamples::RootMaterialWriter::RootMaterialWriter(), ActsExamples::RootTrajectorySummaryReader::RootTrajectorySummaryReader(), ActsExamples::CsvBFieldWriter::run(), ActsExamples::Sequencer::run(), runMaterialMapping(), runMeasurementsToSP(), runRecCKFTracks(), Acts::Experimental::detail::CylindricalDetectorHelper::rzphiBoundaries(), ActsExamples::SpacePointMaker::SpacePointMaker(), Acts::EventDataView3DTest::testMultiTrajectory(), testTruthTestGraph(), trackingGeometry(), vector2D< T >::vector2D(), and vector3D< T >::vector3D().

Here is the call graph for this function:

const Logger & Acts::getDummyLogger

(

)

Definition at line 112 of file Logger.cpp.

View newest version in sPHENIX GitHub at line 112 of file Logger.cpp

References logger().

Referenced by BOOST_AUTO_TEST_CASE(), and ActsExamples::MockupSectorBuilder::buildChamber().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T Acts::getParam	(	const std::string &	key,
		dd4hep::DetElement &	elt
	)

Helper function to extract a parameter value from a dd4hep detector element from VariantParameters

Template Parameters

T	The value type

Parameters

key	The key of the value to extract
elt	The detector element instance

Returns

A copy of the value contained in the params instance

Definition at line 28 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 28 of file DD4hepConversionHelpers.hpp

References Acts::UnitConstants::T.

template<typename T >

T Acts::getParamOr	(	const std::string &	key,
		const dd4hep::DetElement &	elt,
		T	alternative
	)

Get a parameter value or an alternative value if either the VariantParameters extension isn't set, or it doesn't contain the demanded key

Template Parameters

T	The value type

Parameters

key	The key of the value to extract
elt	The detector element instance
alternative	The value to return if no params are set of the key doesn't exist

Returns

The value behind key, or alternative

Definition at line 68 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 68 of file DD4hepConversionHelpers.hpp

References Acts::UnitConstants::T.

dd4hep::rec::VariantParameters& Acts::getParams ( dd4hep::DetElement &  elt )

inline

Helper function to extract a VariantParameters instance

Parameters

elt	The detector element instance

Returns

The VariantParameters instance

Definition at line 39 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 39 of file DD4hepConversionHelpers.hpp

Referenced by addCylinderLayerProtoMaterial(), addDiscLayerProtoMaterial(), Acts::DD4hepLayerBuilder::centralLayers(), Acts::DD4hepLayerBuilder::endcapLayers(), and volumeBuilder_dd4hep().

Here is the caller graph for this function:

const dd4hep::rec::VariantParameters& Acts::getParams ( const dd4hep::DetElement &  elt )

inline

Helper function to extract a VariantParameters instance, const version

Parameters

elt	The detector element instance

Returns

The VariantParameters instance

Definition at line 50 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 50 of file DD4hepConversionHelpers.hpp

std::function< double(Acts::Vector3)> Acts::globalToLocalFromBin

(

Acts::BinningValue &

type

)

return a function that return the coordinate corresponding to type of bin

Parameters

[in]

type

Type of bin

Returns

a coordinate transform function

Definition at line 86 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 86 of file MaterialGridHelper.cpp

References binEta, binH, binMag, binPhi, binR, binRPhi, binValues, binX, binY, binZ, Acts::VectorHelpers::perp(), Acts::VectorHelpers::phi(), and Acts::Test::pos.

Referenced by createGrid2D(), and createGrid3D().

Here is the call graph for this function:

Here is the caller graph for this function:

constexpr HashedString Acts::hashString

(

std::string_view

s

)

Definition at line 38 of file HashedString.hpp.

View newest version in sPHENIX GitHub at line 38 of file HashedString.hpp

References Acts::detail::fnv1a_32().

Referenced by Acts::MutablePodioTrackContainer::addColumn_impl(), Acts::VectorTrackContainer::addColumn_impl(), Acts::VectorMultiTrajectory::addColumn_impl(), Acts::MutablePodioTrackStateContainer::addColumn_impl(), Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::calibrated(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::calibratedCovariance(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::chi2(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::component(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::copyFrom(), ActsExamples::TracksToTrajectories::execute(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::filtered(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::filteredCovariance(), Acts::KalmanFitter< propagator_t, traj_t >::fit(), Acts::GaussianSumFitter< propagator_t, bethe_heitler_approx_t, traj_t >::fit_impl(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::getUncalibratedSourceLink(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::has(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasCalibrated(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasFiltered(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasJacobian(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasPredicted(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasProjector(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasSmoothed(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::hasUncalibratedSourceLink(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::jacobian(), Acts::detail_lt::TrackStateRange< reverse, trajectory_t, M, ReadOnly >::Iterator::operator++(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::pathLength(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::predicted(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::predictedCovariance(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::projector(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::projectorBitset(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::setProjector(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::setProjectorBitset(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::smoothed(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::smoothedCovariance(), Acts::Test::MultiTrajectoryTestsCommon< factory_t >::testMultiTrajectoryExtraColumns(), Acts::Test::MultiTrajectoryTestsCommon< factory_t >::testMultiTrajectoryExtraColumnsRuntime(), and Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::typeFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

bool Acts::hasParam ( const std::string &  key, dd4hep::DetElement &  elt  )

inline

Check if a detector element has a key set in its VariantParameters

Parameters

key	The key to check existence for
elt	The detector element instance

Returns

True if the element has VariantParameters and the key exists, false if either of these is not true

Definition at line 82 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 82 of file DD4hepConversionHelpers.hpp

Referenced by volumeBuilder_dd4hep().

Here is the caller graph for this function:

bool Acts::hasParams ( dd4hep::DetElement &  elt )

inline

Check if a detector element has VariantParameters set

Parameters

elt	The detector element instance

Returns

True if the VariantParameters exist, false if not

Definition at line 93 of file DD4hepConversionHelpers.hpp.

View newest version in sPHENIX GitHub at line 93 of file DD4hepConversionHelpers.hpp

Referenced by addCylinderLayerProtoMaterial(), addDiscLayerProtoMaterial(), and ActsExamples::RootTrajectoryStatesWriter::writeT().

Here is the caller graph for this function:

Acts::if

(

!ifj.

good()

)

Definition at line 34 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 34 of file JsonMaterialDecorator.cpp

Referenced by Acts::SpacePointGridCreator::createGrid(), Acts::SeedFinder< external_spacepoint_t, platform_t >::createSeedsForGroup(), Acts::SeedFinder< external_spacepoint_t, platform_t >::filterCandidates(), Acts::SeedFinderOrthogonal< external_spacepoint_t >::filterCandidates(), Acts::SeedFilter< external_spacepoint_t >::filterSeeds_2SpFixed(), Acts::CylinderBounds::inside3D(), and Acts::DirectNavigator::postStep().

Here is the caller graph for this function:

Acts::if

(

jFileName.find(".cbor")!

= std::string::npos

)

Definition at line 40 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 40 of file JsonMaterialDecorator.cpp

References ifj().

Here is the call graph for this function:

std::ifstream Acts::ifj

(

jFileName.

c_str()

)

Referenced by if().

Here is the caller graph for this function:

template<typename T , size_t N, class Point1 , class Point2 = Point1, class Point3 = Point2, typename = std::enable_if_t< detail::can_interpolate<Point1, Point2, Point3, T>::value>>

T Acts::interpolate ( const Point1 &  position, const Point2 &  lowerCorner, const Point3 &  upperCorner, const std::array< T, N > &  values  )

inline

performs linear interpolation inside a hyper box

Template Parameters

T	type of values to be interpolated
N	number of hyper box corners
Point1	type specifying geometric positions
Point2	type specifying geometric positions
Point3	type specifying geometric positions

Parameters

[in]	position	position to which to interpolate
[in]	lowerCorner	generalized lower-left corner of hyper box (containing the minima of the hyper box along each dimension)
[in]	upperCorner	generalized upper-right corner of hyper box (containing the maxima of the hyper box along each dimension)
[in]	values	field values at the hyper box corners sorted in the canonical order defined below.

Returns

interpolated value at given position

Precondition

position must describe a position inside the given hyper box, that is .

Note

• Given U and V of value type T as well as two double a and b, then the following must be a valid expression a * U + b * V yielding an object which is (implicitly) convertible to T.
• All Point types must represent d-dimensional positions and support coordinate access using operator[] which should return a double (or a value which is implicitly convertible). Coordinate indices must start at 0.
• N is the number of hyper box corners which is where is the dimensionality of the hyper box. The dimensionality must be consistent with the provided Point types.
• Definition of the canonical order for sorting the field values: The hyper box corners are numbered according to the following scheme. Each corner is defined by the set of lower/upper boundary limits in each dimension i. This can be represented by a binary code (from left to right) where a 0 stands for a lower bound along this axis and a 1 stand for the upper bound along this axis. The left most bit corresponds to the first dimension and the bits to the left correspond to the 2nd, 3rd... dimension. The binary code can be interpreted as integer which gives the number of the corresponding hyper box corner. The field values are ordered according to ascending hyper box corner numbers.
  As an example assume we have a 3D box with lowerCorner = (1,2,3) and upperCorner = (4,5,6). The eight corners with their bit patterns and corner numbers are:
  • (1,2,3): 000 = 0
  • (1,2,6): 001 = 1
  • (1,5,3): 010 = 2
  • (1,5,6): 011 = 3
  • (4,2,3): 100 = 4
  • (4,2,6): 101 = 5
  • (4,5,3): 110 = 6
  • (4,5,6): 111 = 7

Definition at line 78 of file Interpolation.hpp.

View newest version in sPHENIX GitHub at line 78 of file Interpolation.hpp

References N, utils::run, and Acts::UnitConstants::T.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::InterpolatedBFieldMap< grid_t >::FieldCell::getField(), Acts::MaterialMapper< G >::MaterialCell::getMaterial(), Acts::detail::Grid< external_spacepoint_t >::interpolate(), and AnnularFieldSim::swimToInSteps().

Here is the caller graph for this function:

static bool Acts::isEqual ( const BinningData &  ba, const BinningData &  bb, float  tolerance  )

inlinestatic

Check whether the BinningData objects are equal

Parameters

ba	The first BinningData object
bb	The second BinningData object
tolerance	a tolerance parameter

Returns

a boolean

Definition at line 29 of file EqualityHelpers.hpp.

View newest version in sPHENIX GitHub at line 29 of file EqualityHelpers.hpp

References Acts::BinningData::binvalue, Acts::BinningData::boundaries(), add_histos_bX::ib, Acts::BinningData::max, Acts::BinningData::min, Acts::BinningData::option, Acts::BinningData::step, Acts::BinningData::subBinningAdditive, Acts::BinningData::subBinningData, Acts::Test::tolerance, Acts::BinningData::type, and Acts::BinningData::zdim.

Referenced by BOOST_AUTO_TEST_CASE(), and isEqual().

Here is the call graph for this function:

Here is the caller graph for this function:

static bool Acts::isEqual ( const BinUtility &  ba, const BinUtility &  bb, float  tolerance  )

inlinestatic

Check whether the BinUtility objects are equal

Parameters

ba	The first BinUtility object
bb	the second BinUtility object
tolerance	a tolerance parameter

Returns

a bollean if equal

Definition at line 70 of file EqualityHelpers.hpp.

View newest version in sPHENIX GitHub at line 70 of file EqualityHelpers.hpp

References Acts::BinUtility::binningData(), add_histos_bX::ib, isEqual(), and Acts::Test::tolerance.

Here is the call graph for this function:

static bool Acts::isEqual ( const Acts::Extent &  ea, const Acts::Extent &  eb, Acts::ActsScalar  tolerance = 0.  )

inlinestatic

check whether Extnet objects are equal - with tolerance

Parameters

ea	the first extent object
eb	the second extent object
tolerance	the tolerance parameter

Returns

bool for euqal

Definition at line 90 of file EqualityHelpers.hpp.

View newest version in sPHENIX GitHub at line 90 of file EqualityHelpers.hpp

References Acts::Extent::constrains(), Acts::Extent::max(), Acts::Extent::min(), s_binningValues, and Acts::Test::tolerance.

Here is the call graph for this function:

std::error_code Acts::make_error_code

(

Acts::MagneticFieldError

e

)

Definition at line 35 of file MagneticFieldError.cpp.

View newest version in sPHENIX GitHub at line 35 of file MagneticFieldError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::SurfaceError

e

)

Definition at line 36 of file SurfaceError.cpp.

View newest version in sPHENIX GitHub at line 36 of file SurfaceError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::EigenStepperError

e

)

Definition at line 39 of file EigenStepperError.cpp.

View newest version in sPHENIX GitHub at line 39 of file EigenStepperError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::PropagatorError

e

)

Definition at line 39 of file PropagatorError.cpp.

View newest version in sPHENIX GitHub at line 39 of file PropagatorError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::GsfError

e

)

Definition at line 43 of file GsfError.cpp.

View newest version in sPHENIX GitHub at line 43 of file GsfError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::CombinatorialKalmanFilterError

e

)

Definition at line 46 of file CombinatorialKalmanFilterError.cpp.

View newest version in sPHENIX GitHub at line 46 of file CombinatorialKalmanFilterError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::VertexingError

e

)

Definition at line 45 of file VertexingError.cpp.

View newest version in sPHENIX GitHub at line 45 of file VertexingError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::KalmanFitterError

e

)

Definition at line 43 of file KalmanFitterError.cpp.

View newest version in sPHENIX GitHub at line 43 of file KalmanFitterError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

std::error_code Acts::make_error_code

(

Acts::MultiStepperError

e

)

Definition at line 46 of file MultiStepperError.cpp.

View newest version in sPHENIX GitHub at line 46 of file MultiStepperError.cpp

References Acts::PhysicalConstants::c, and Acts::UnitConstants::e.

template<typename box_t >

box_t * Acts::make_octree	(	std::vector< std::unique_ptr< box_t >> &	store,
		const std::vector< box_t * > &	prims,
		size_t	max_depth = 1,
		typename box_t::value_type	envelope1 = 0
	)

Build an octree from a list of bounding boxes.

Note

store and prims do not need to contain the same objects. store is only used to pass ownership back to the caller while preserving memory location.

Template Parameters

box_t

Works will all box types.

Parameters

store	Owns the created boxes by means of std::unique_ptr.
prims	Boxes to store. This is a read only vector.
max_depth	No subdivisions beyond this level.
envelope1	Envelope to add/subtract to dimensions in all directions.

Returns

Pointer to the top most bounding box, containing the entire octree

Definition at line 535 of file BoundingBox.ipp.

View newest version in sPHENIX GitHub at line 535 of file BoundingBox.ipp

References Acts::Test::dim, octree_inner(), and store.

Referenced by Acts::Test::CubicBVHTrackingGeometry::CubicBVHTrackingGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

static constexpr PdgParticle Acts::makeAbsolutePdgParticle ( PdgParticle  pdg )

inlinestatic

Convert an anti-particle to its particle and leave particles as-is.

Definition at line 37 of file PdgParticle.hpp.

View newest version in sPHENIX GitHub at line 37 of file PdgParticle.hpp

References pdg, and value.

Referenced by ActsFatras::Particle::absolutePdg(), BOOST_DATA_TEST_CASE(), computeEnergyLossRadiative(), computeMultipleScatteringTheta0(), deriveEnergyLossRadiativeQOverP(), ActsFatras::Geant4Decay::generateProperTimeLimit(), ActsFatras::PDGtoG4Converter::getParticleDefinition(), main(), ActsFatras::AbsPdgSelector< Pdg >::operator()(), ActsFatras::AbsPdgExcluder< Pdg >::operator()(), and pdgToShortAbsString().

Here is the caller graph for this function:

template<typename InputVector >

auto Acts::makeCurvilinearUnitU ( const Eigen::MatrixBase< InputVector > &  direction )

inline

Construct the first curvilinear unit vector U for the given direction.

Parameters

direction

is the input direction vector

Returns

a normalized vector in the x-y plane orthogonal to the direction.

The special case of the direction vector pointing along the z-axis is handled by forcing the unit vector to along the x-axis.

Definition at line 82 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 82 of file UnitVectors.hpp

References norm.

Referenced by ActsFatras::BetheHeitler::bremPhoton(), ActsFatras::PhotonConversion::generateChildDirection(), makeCurvilinearUnitVectors(), and ActsFatras::detail::ScatteringImpl< scattering_model_t >::operator()().

Here is the caller graph for this function:

template<typename InputVector >

auto Acts::makeCurvilinearUnitVectors ( const Eigen::MatrixBase< InputVector > &  direction )

inline

Construct the curvilinear unit vectors U and V for the given direction.

Parameters

direction

is the input direction vector

Returns

normalized unit vectors U and V orthogonal to the direction.

With T the normalized input direction, the three vectors U, V, and T form an orthonormal basis set, i.e. they satisfy

U x V = T
V x T = U
T x U = V

with the additional condition that U is located in the global x-y plane.

Definition at line 124 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 124 of file UnitVectors.hpp

References makeCurvilinearUnitU().

Referenced by Acts::GeometryView3D::drawSegmentBase(), and makeCurvilinearTransform().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::AtlasBetheHeitlerApprox< 6, 5 > Acts::makeDefaultBetheHeitlerApprox

(

)

Creates a AtlasBetheHeitlerApprox object based on an ATLAS configuration, that are stored as static data in the source code. This may not be an optimal configuration, but should allow to run the GSF without the need to load files

Definition at line 11 of file BetheHeitlerApprox.cpp.

View newest version in sPHENIX GitHub at line 11 of file BetheHeitlerApprox.cpp

Referenced by Acts::Python::addTrackFitting(), and PHActsGSF::InitRun().

Here is the caller graph for this function:

template<typename T >

Eigen::Matrix<T, 3, 1> Acts::makeDirectionFromPhiEta ( T  phi, T  eta  )

inline

Construct a normalized direction vector from phi angle and pseudorapidity.

Parameters

phi	is the direction angle in the x-y plane.
eta	is the pseudorapidity towards the z-axis.

Note

The input arguments intentionally use the same template type so that a compile error occurs if inconsistent input types are used. Avoids unexpected implicit type conversions and forces the user to explicitly cast mismatched input types.

Definition at line 29 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 29 of file UnitVectors.hpp

Referenced by BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), and BOOST_DATA_TEST_CASE().

Here is the caller graph for this function:

template<typename T >

Eigen::Matrix<T, 3, 1> Acts::makeDirectionFromPhiTheta ( T  phi, T  theta  )

inline

Construct a normalized direction vector from phi and theta angle.

Parameters

phi	is the direction angle in radian in the x-y plane.
theta	is the polar angle in radian towards the z-axis.

Note

The input arguments intentionally use the same template type so that a compile error occurs if inconsistent input types are used. Avoids unexpected implicit type conversions and forces the user to explicitly cast mismatched input types.

Definition at line 48 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 48 of file UnitVectors.hpp

Referenced by BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), ActsFatras::NuclearInteraction::convertParametersToParticles(), Acts::GenericBoundTrackParameters< ParticleHypothesis >::direction(), ActsAlignmentStates::fillAlignmentStateMap(), Acts::GenericFreeTrackParameters< particle_hypothesis_t >::GenericFreeTrackParameters(), and Acts::detail::transformBoundToFreeParameters().

Here is the caller graph for this function:

template<typename parameters_t , typename covariance_t , typename indices_t , typename... tail_indices_t>

auto Acts::makeMeasurement	(	SourceLink	source,
		const Eigen::MatrixBase< parameters_t > &	params,
		const Eigen::MatrixBase< covariance_t > &	cov,
		indices_t	index0,
		tail_indices_t...	tailIndices
	)		-> Measurement<indices_t, 1u + sizeof...(tail_indices_t)>

Construct a fixed-size measurement for the given indices.

Template Parameters

parameters_t	Input parameters vector type
covariance_t	Input covariance matrix type
indices_t	Parameter index type, determines the full parameter space
tail_indices_t	Helper types required to support variadic arguments; all types must be convertibale to indices_t.

Parameters

source	The link that connects to the underlying detector readout
params	Measured parameters values
cov	Measured parameters covariance
index0	Required parameter index, measurement must be at least 1d
tailIndices	Additional parameter indices for larger measurements

Returns

Fixed-size measurement w/ the correct type and given inputs

This helper function can be used to create a fixed-size measurement using an explicit set of indices, e.g.

auto m = makeMeasurement(s, p, c, eBoundLoc0, eBoundTime);

for a 2d measurement w/ one position and time.

Note

The indices must be ordered and must be consistent with the content of parameters and covariance.

Definition at line 190 of file Measurement.hpp.

View newest version in sPHENIX GitHub at line 190 of file Measurement.hpp

References TauVsDIS_MachineLearning_Differentiation::array, Acts::Test::cov, index0, testing::internal::move(), parse_cmake_options::source, and physmon_ckf_tracking::u.

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), ActsExamples::PlanarSteppingAlgorithm::execute(), and Acts::Test::testSourceLinkCalibratorReturn().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

Eigen::Matrix<T, 2, 1> Acts::makePhiThetaFromDirection ( Eigen::Matrix< T, 3, 1 >  unitDir )

inline

Construct a phi and theta angle from a direction vector.

Parameters

unitDir

3D vector indicating a direction

Definition at line 63 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 63 of file UnitVectors.hpp

References ActsTests::PropagationDatasets::phi, Acts::UnitConstants::T, and ActsTests::PropagationDatasets::theta.

Referenced by ActsExamples::VertexPerformanceWriter::writeT().

Here is the caller graph for this function:

Acts::MaterialGrid3D Acts::mapMaterialPoints

(

Acts::Grid2D &

grid

)

Average the material collected in a 2D grid and use it to create a 2D material grid.

Average the material collected in a 3D grid and use it to create a 3D material grid.

Parameters

[in]

grid

The material collecting grid coordinate

Returns

The average material grid decomposed into classification numbers

Definition at line 212 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 212 of file MaterialGridHelper.cpp

References Acts::detail::Grid< T, Axes >::at(), index, std::tr1::make_tuple(), Acts::detail::Grid< T, Axes >::maxPosition(), Acts::UnitConstants::min, Acts::detail::Grid< T, Axes >::minPosition(), Acts::detail::Grid< T, Axes >::numLocalBins(), and Acts::detail::Grid< T, Axes >::size().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and Acts::VolumeMaterialMapper::finalizeMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

auto Acts::materialMapperRZ	(	const std::function< size_t(std::array< size_t, 2 > binsRZ, std::array< size_t, 2 > nBinsRZ)> &	materialVectorToGridMapper,
		std::vector< double >	rPos,
		std::vector< double >	zPos,
		const std::vector< Acts::Material > &	material,
		double	lengthUnit = UnitConstants::mm
	)

Method to setup the MaterialMapper

Parameters

[in]

materialVectorToGridMapper

Function mapping the vector of material to the map of material values

e.g.: we have small grid with the values: r={2,3}, z ={4,5}, the corresponding indices are i (belonging to r) and j (belonging to z), the globalIndex is M (belonging to the values of the Material) and the map is:

r	i	z	j	M
2	0	4	0	0
2	0	5	1	1
3	1	4	0	2
3	1	5	1	3

In this case the function would look like:

[](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) {
   return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1));
}

Parameters

[in]

rPos

Values of the grid points in r

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

zPos

Values of the grid points in z

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

material

The material classification values in r and z for all given grid points stored in a vector

Note

The function localToGlobalBin determines how the material was stored in the vector in respect to the grid values

Parameters

[in]

lengthUnit

The unit of the grid points

Definition at line 28 of file MaterialMapUtils.cpp.

View newest version in sPHENIX GitHub at line 28 of file MaterialMapUtils.cpp

References grid(), i, j, ActsExamples::HepMC3Event::lengthUnit(), std::tr1::make_tuple(), material, testing::internal::move(), Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), Acts::Test::pos, Acts::Experimental::detail::BlueprintHelper::sort(), and vec.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

auto Acts::materialMapperXYZ	(	const std::function< size_t(std::array< size_t, 3 > binsXYZ, std::array< size_t, 3 > nBinsXYZ)> &	materialVectorToGridMapper,
		std::vector< double >	xPos,
		std::vector< double >	yPos,
		std::vector< double >	zPos,
		const std::vector< Material > &	material,
		double	lengthUnit = UnitConstants::mm
	)

Method to setup the MaterialMapper

Parameters

[in]

materialVectorToGridMapper

Function mapping the vector of material to the map of material values

e.g.: we have small grid with the values: x={2,3}, y={3,4}, z ={4,5}, the corresponding indices are i (belonging to x), j (belonging to y) and k (belonging to z), the globalIndex is M (belonging to the values of the Material) and the map is:

x	i	y	j	z	k	M
2	0	3	0	4	0	0
2	0	3	0	5	1	1
2	0	4	1	4	0	2
2	0	4	1	5	1	3
3	1	3	0	4	0	4
3	1	3	0	5	1	5
3	1	4	1	4	0	6
3	1	4	1	5	1	7

In this case the function would look like:

[](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) {
  return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2))
       + binsXYZ.at(1) * nBinsXYZ.at(2)
       + binsXYZ.at(2));
}

Parameters

[in]

xPos

Values of the grid points in x

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

yPos

Values of the grid points in y

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

zPos

Values of the grid points in z

Note

The values do not need to be sorted or unique (this will be done inside the function)

Parameters

[in]

material

The material classification values in x, y and z for all given grid points stored in a vector

Note

The function localToGlobalBin determines how the material was stored in the vector in respect to the grid values

Parameters

[in]

lengthUnit

The unit of the grid points

Definition at line 111 of file MaterialMapUtils.cpp.

View newest version in sPHENIX GitHub at line 111 of file MaterialMapUtils.cpp

References grid(), i, j, k, ActsExamples::HepMC3Event::lengthUnit(), std::tr1::make_tuple(), material, testing::internal::move(), Acts::IntegrationTest::nBinsZ, Acts::Test::pos, Acts::Experimental::detail::BlueprintHelper::sort(), and vec.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Derived >

auto Acts::matrixToBitset

(

const Eigen::PlainObjectBase< Derived > &

m

)

Convert an integer matrix to a bitset.

Note

How the bits are ordered depends on the storage type of the matrix being converted (row-major or col-major)

Template Parameters

Derived

Eigen base concrete type

Parameters

m	Matrix that is converted

Returns

The converted bitset.

Definition at line 52 of file AlgebraHelpers.hpp.

View newest version in sPHENIX GitHub at line 52 of file AlgebraHelpers.hpp

References i, merge_hashes::p, and parse_cmake_options::rows.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::setProjector().

Here is the caller graph for this function:

template<typename T >

std::array<typename T::value_type, 2u> Acts::min_max

(

const T &

tseries

)

Return min/max from a (optionally) sorted series, obsolete with C++20 (ranges)

Template Parameters

T	a numeric series

Parameters

tseries

is the number series

Returns

[ min, max ] in an array of length 2

Definition at line 175 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 175 of file Helpers.hpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), ActsExamples::MockupSectorBuilder::buildChamber(), and range_medium().

Here is the caller graph for this function:

bool Acts::operator!= ( const DigitizationSourceLink &  lhs, const DigitizationSourceLink &  rhs  )

inline

Definition at line 53 of file DigitizationSourceLink.hpp.

View newest version in sPHENIX GitHub at line 53 of file DigitizationSourceLink.hpp

Referenced by Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::componentIterable(), Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::constComponentIterable(), enumerate(), and zip().

Here is the caller graph for this function:

bool Acts::operator!= ( const SurfaceBounds &  lhs, const SurfaceBounds &  rhs  )

inline

Definition at line 84 of file SurfaceBounds.hpp.

View newest version in sPHENIX GitHub at line 84 of file SurfaceBounds.hpp

References check_smearing_config::rhs.

constexpr int Acts::operator* ( Direction  dir, int  value  )

inline

Definition at line 113 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 113 of file Direction.hpp

References Acts::Direction::sign(), and value.

Referenced by Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::componentIterable(), Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::constComponentIterable(), enumerate(), and zip().

Here is the call graph for this function:

Here is the caller graph for this function:

constexpr float Acts::operator* ( Direction  dir, float  value  )

inline

Definition at line 117 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 117 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

constexpr double Acts::operator* ( Direction  dir, double  value  )

inline

Definition at line 121 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 121 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

Acts::Vector3 Acts::operator* ( Direction  dir, const Acts::Vector3 &  value  )

inline

Definition at line 125 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 125 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

constexpr int Acts::operator* ( int  value, Direction  dir  )

inline

Definition at line 131 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 131 of file Direction.hpp

References Acts::Direction::sign().

Here is the call graph for this function:

constexpr float Acts::operator* ( float  value, Direction  dir  )

inline

Definition at line 135 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 135 of file Direction.hpp

References Acts::Direction::sign().

Here is the call graph for this function:

constexpr double Acts::operator* ( double  value, Direction  dir  )

inline

Definition at line 139 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 139 of file Direction.hpp

References Acts::Direction::sign().

Here is the call graph for this function:

Acts::Vector3 Acts::operator* ( const Acts::Vector3 &  value, Direction  dir  )

inline

Definition at line 143 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 143 of file Direction.hpp

References Acts::Direction::sign().

Here is the call graph for this function:

constexpr int Acts::operator*= ( int &  value, Direction  dir  )

inline

Definition at line 149 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 149 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

constexpr float Acts::operator*= ( float &  value, Direction  dir  )

inline

Definition at line 154 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 154 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

constexpr double Acts::operator*= ( double &  value, Direction  dir  )

inline

Definition at line 159 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 159 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

Acts::Vector3& Acts::operator*= ( Acts::Vector3 &  value, Direction  dir  )

inline

Definition at line 164 of file Direction.hpp.

View newest version in sPHENIX GitHub at line 164 of file Direction.hpp

References Acts::Direction::sign(), and value.

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	os,
		MaterialUpdateStage	matUpdate
	)

Definition at line 15 of file Common.cpp.

View newest version in sPHENIX GitHub at line 15 of file Common.cpp

References assert, and os.

std::ostream& Acts::operator<< ( std::ostream &  os, IntersectionStatus  status  )

inline

Ostream-operator for the IntersectionStatus enum.

Definition at line 33 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 33 of file Intersection.hpp

References TauVsDIS_MachineLearning_Differentiation::names, os, and utils::status.

std::ostream& Acts::operator<<	(	std::ostream &	os,
		const VersionInfo &	vi
	)

Definition at line 36 of file ActsVersion.cpp.

View newest version in sPHENIX GitHub at line 36 of file ActsVersion.cpp

References os.

std::ostream& Acts::operator<<	(	std::ostream &	os,
		FpeType	type
	)

std::ostream & Acts::operator<<	(	std::ostream &	os,
		TrackStatePropMask	mask
	)

Definition at line 17 of file TrackStatePropMask.cpp.

View newest version in sPHENIX GitHub at line 17 of file TrackStatePropMask.cpp

References ACTS_CHECK_BIT, and os.

std::ostream & Acts::operator<<	(	std::ostream &	os,
		Acts::PdgParticle	pdg
	)

Print PDG particle numbers with a descriptive name.

Definition at line 99 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 99 of file ParticleData.cpp

References findName(), perf_headwind::name, os, and pdg.

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, BoundarySurfaceFace &  face  )

inline

Definition at line 58 of file BoundarySurfaceFace.hpp.

View newest version in sPHENIX GitHub at line 58 of file BoundarySurfaceFace.hpp

References negativeFaceXY, negativeFaceYZ, negativeFaceZX, os, positiveFaceXY, positiveFaceYZ, positiveFaceZX, and undefinedFace.

template<typename T , size_t D>

std::ostream& Acts::operator<<	(	std::ostream &	os,
		const Ray< T, D > &	ray
	)

Overload of the outstream operator

Parameters

os	The out stream
ray	The ray to write to os

Returns

The outstream given in os

Definition at line 76 of file Ray.hpp.

View newest version in sPHENIX GitHub at line 76 of file Ray.hpp

References os.

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const GlueVolumesDescriptor &	gvd
	)

Definition at line 71 of file GlueVolumesDescriptor.cpp.

View newest version in sPHENIX GitHub at line 71 of file GlueVolumesDescriptor.cpp

References Acts::GlueVolumesDescriptor::screenOutput().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	os,
		const MaterialSlab &	materialSlab
	)

Definition at line 56 of file MaterialSlab.cpp.

View newest version in sPHENIX GitHub at line 56 of file MaterialSlab.cpp

References Acts::MaterialSlab::material(), os, and Acts::MaterialSlab::thickness().

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const SurfaceBounds &  sb  )

inline

Definition at line 88 of file SurfaceBounds.hpp.

View newest version in sPHENIX GitHub at line 88 of file SurfaceBounds.hpp

References Acts::SurfaceBounds::toStream().

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const IVisualization3D &  hlp  )

inline

Overload of the << operator to facilitate writing to streams.

Parameters

os	The output stream
hlp	The helper instance

Definition at line 97 of file IVisualization3D.hpp.

View newest version in sPHENIX GitHub at line 97 of file IVisualization3D.hpp

References os, and Acts::IVisualization3D::write().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	os,
		Direction	dir
	)

Definition at line 25 of file Direction.cpp.

View newest version in sPHENIX GitHub at line 25 of file Direction.cpp

References os, and Acts::Direction::toString().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	os,
		const Material &	material
	)

Definition at line 98 of file Material.cpp.

View newest version in sPHENIX GitHub at line 98 of file Material.cpp

References Acts::Material::Ar(), Acts::Material::L0(), Acts::Material::molarDensity(), os, Acts::Material::X0(), and Acts::Material::Z().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const Volume &	vol
	)

Overload of << operator for std::ostream for debug output

Definition at line 65 of file Volume.cpp.

View newest version in sPHENIX GitHub at line 65 of file Volume.cpp

References Acts::Volume::volumeBounds().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const VolumeBounds &	vb
	)

Overload of << operator for std::ostream for debug output.

Overload of << operator for std::ostream for debug output

Definition at line 12 of file VolumeBounds.cpp.

View newest version in sPHENIX GitHub at line 12 of file VolumeBounds.cpp

References Acts::VolumeBounds::toStream().

Here is the call graph for this function:

std::ostream & Acts::operator<<	(	std::ostream &	os,
		GeometryIdentifier	id
	)

Definition at line 14 of file GeometryIdentifier.cpp.

View newest version in sPHENIX GitHub at line 14 of file GeometryIdentifier.cpp

References i, levels, TauVsDIS_MachineLearning_Differentiation::names, os, physmon_ckf_tracking::u, and value.

std::ostream& Acts::operator<< ( std::ostream &  os, const ConstrainedStep &  step  )

inline

Definition at line 175 of file ConstrainedStep.hpp.

View newest version in sPHENIX GitHub at line 175 of file ConstrainedStep.hpp

References Acts::ConstrainedStep::toStream().

Here is the call graph for this function:

template<typename indices_t >

std::ostream& Acts::operator<<	(	std::ostream &	os,
		const VariantMeasurement< indices_t > &	vm
	)

Definition at line 241 of file Measurement.hpp.

View newest version in sPHENIX GitHub at line 241 of file Measurement.hpp

References Acts::UnitConstants::m.

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const Extent &	rhs
	)

Overload of << operator for std::ostream for debug output.

Definition at line 188 of file Extent.cpp.

View newest version in sPHENIX GitHub at line 188 of file Extent.cpp

References Acts::Extent::toString().

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const TrackSelector::Config &  cuts  )

inline

Print this set of cuts to an output stream

Parameters

os	Output stream
cuts	Cuts to print

Returns

Reference to the output stream

Definition at line 259 of file TrackSelector.hpp.

View newest version in sPHENIX GitHub at line 259 of file TrackSelector.hpp

References Acts::TrackSelector::Config::absEtaMax, Acts::TrackSelector::Config::absEtaMin, Acts::TrackSelector::Config::etaMax, Acts::TrackSelector::Config::etaMin, Acts::TrackSelector::Config::loc0Max, Acts::TrackSelector::Config::loc0Min, Acts::TrackSelector::Config::loc1Max, Acts::TrackSelector::Config::loc1Min, Acts::UnitConstants::min, Acts::TrackSelector::Config::minMeasurements, perf_headwind::name, os, Acts::TrackSelector::Config::phiMax, Acts::TrackSelector::Config::phiMin, print(), Acts::TrackSelector::Config::ptMax, Acts::TrackSelector::Config::ptMin, Acts::TrackSelector::Config::timeMax, and Acts::TrackSelector::Config::timeMin.

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const TrackSelector::EtaBinnedConfig &  cfg  )

inline

Print this configuration to an output stream

Parameters

os	Output stream
cfg	Configuration to print

Returns

Reference to the output stream

Definition at line 317 of file TrackSelector.hpp.

View newest version in sPHENIX GitHub at line 317 of file TrackSelector.hpp

References Acts::TrackSelector::EtaBinnedConfig::absEtaEdges, Acts::TrackSelector::EtaBinnedConfig::cutSets, i, and os.

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const BinUtility &	bgen
	)

Overload of << operator for std::ostream for debug output.

Definition at line 13 of file BinUtility.cpp.

View newest version in sPHENIX GitHub at line 13 of file BinUtility.cpp

References Acts::BinUtility::toStream().

Here is the call graph for this function:

template<typename T , typename U , size_t V>

std::ostream & Acts::operator<<	(	std::ostream &	os,
		const AxisAlignedBoundingBox< T, U, V > &	box
	)

Overload of the << operator for bounding boxes.

Template Parameters

T	entity type
U	value type
V	dimension

Parameters

os	The output stream
box	The bounding box

Returns

The given output stream.

Definition at line 549 of file BoundingBox.ipp.

View newest version in sPHENIX GitHub at line 549 of file BoundingBox.ipp

References Acts::AxisAlignedBoundingBox< entity_t, value_t, DIM >::toStream().

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const std::tuple< const Surface &, const GeometryContext & > &  tup  )

inline

Print surface information to the provided stream. Internally invokes the surface.toStream(...)-method. This can be easily used e.g. like std::cout << std::tie(surface, geometryContext);

Definition at line 532 of file Surface.hpp.

View newest version in sPHENIX GitHub at line 532 of file Surface.hpp

References gctx, os, and writeMapConfig::surface.

bool Acts::operator== ( const DigitizationSourceLink &  lhs, const DigitizationSourceLink &  rhs  )

inline

Definition at line 48 of file DigitizationSourceLink.hpp.

View newest version in sPHENIX GitHub at line 48 of file DigitizationSourceLink.hpp

References Acts::DigitizationSourceLink::geometryId(), and Acts::DigitizationSourceLink::indices().

Referenced by Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::componentIterable(), Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::constComponentIterable(), and Acts::Surface::operator!=().

Here is the call graph for this function:

Here is the caller graph for this function:

bool Acts::operator== ( const SurfaceBounds &  lhs, const SurfaceBounds &  rhs  )

inline

Definition at line 77 of file SurfaceBounds.hpp.

View newest version in sPHENIX GitHub at line 77 of file SurfaceBounds.hpp

References Acts::SurfaceBounds::type(), and Acts::SurfaceBounds::values().

Here is the call graph for this function:

bool Acts::operator== ( const VolumeBounds &  lhs, const VolumeBounds &  rhs  )

inline

Definition at line 147 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 147 of file VolumeBounds.hpp

References Acts::VolumeBounds::type(), and Acts::VolumeBounds::values().

Here is the call graph for this function:

std::optional< std::string_view > Acts::pdgToShortAbsString

(

PdgParticle

pdg

)

Definition at line 109 of file ParticleData.cpp.

View newest version in sPHENIX GitHub at line 109 of file ParticleData.cpp

References eElectron, eLead, eMuon, eNeutron, ePionPlus, ePionZero, eProton, eTau, and makeAbsolutePdgParticle().

Here is the call graph for this function:

template<typename T >

std::tuple<typename T::value_type, ActsScalar> Acts::range_medium

(

const T &

tseries

)

Return range and medium of a sorted numeric series

Template Parameters

T	a numeric series

Parameters

tseries

is the number series

Returns

[ range, medium ] in an tuple

Definition at line 188 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 188 of file Helpers.hpp

References Acts::UnitConstants::min, and min_max().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename mixture_t , typename projector_t = Acts::Identity>

auto Acts::reduceGaussianMixture	(	const mixture_t &	mixture,
		const Surface &	surface,
		MixtureReductionMethod	method,
		projector_t &&	projector = projector_t{}
	)

Reduce Gaussian mixture

Parameters

mixture	The mixture iterable
surface	The surface, on which the bound state is
method	How to reduce the mixture
projector	How to project a element of the iterable to something like a std::tuple< double, BoundVector, BoundMatrix >

Returns

parameters and covariance as std::tuple< BoundVector, BoundMatrix >

Definition at line 223 of file GaussianMixtureReduction.hpp.

View newest version in sPHENIX GitHub at line 223 of file GaussianMixtureReduction.hpp

Referenced by Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::addCombinedState(), and Acts::GaussianSumFitter< propagator_t, bethe_heitler_approx_t, traj_t >::fit_impl().

Here is the caller graph for this function:

void Acts::reduceMixtureWithKLDistance	(	std::vector< GsfComponent > &	cmpCache,
		std::size_t	maxCmpsAfterMerge,
		const Surface &	surface
	)

Definition at line 52 of file GsfMixtureReduction.cpp.

View newest version in sPHENIX GitHub at line 52 of file GsfMixtureReduction.cpp

References KFPMath::a, Acts::detail::angleDescriptionSwitch(), proj(), and reduceWithKLDistanceImpl().

Referenced by BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

constexpr T Acts::safeExp ( T  val )

noexcept

Calculate the exponential function while avoiding FPEs.

Parameters

val	argument for which the exponential function should be evaluated.

Returns

0 in the case of underflow, std::numeric_limits<T>::infinity in the case of overflow, std::exp(val) else

Definition at line 222 of file AlgebraHelpers.hpp.

View newest version in sPHENIX GitHub at line 222 of file AlgebraHelpers.hpp

References Acts::UnitConstants::T.

Referenced by Acts::AdaptiveGridTrackDensity< spatialTrkGridSize, temporalTrkGridSize >::multivariateGaussian(), and Acts::GaussianGridTrackDensity< mainGridSize, trkGridSize >::normal2D().

Here is the caller graph for this function:

template<typename MatrixType , typename ResultType = MatrixType>

std::optional<ResultType> Acts::safeInverse ( const MatrixType &  m )

noexcept

FPE "safe" functions

Our main motivation for this is that users might have a strict FPE policy which would flag every single occurrence as a failure and then somebody has to investigate. Since we are processing a high number of events and floating point numbers sometimes work in mysterious ways the caller of this function might want to hide FPEs and handle them in a more controlled way. Calculate the inverse of an Eigen matrix after checking if it can be numerically inverted. This allows to catch potential FPEs before they occur.

Template Parameters

Derived	Eigen derived concrete type
Result	Eigen result type defaulted to input type

Parameters

m	Eigen matrix to invert

Returns

The theta value

Definition at line 188 of file AlgebraHelpers.hpp.

View newest version in sPHENIX GitHub at line 188 of file AlgebraHelpers.hpp

References Acts::UnitConstants::m.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t >::isMergedVertex().

Here is the caller graph for this function:

Acts::InterpolatedBFieldMap< Acts::detail::Grid< Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::solenoidFieldMap	(	std::pair< double, double >	rlim,
		std::pair< double, double >	zlim,
		std::pair< size_t, size_t >	nbins,
		const SolenoidBField &	field
	)

Function which takes an existing SolenoidBField instance and creates a field mapper by sampling grid points from the analytical solenoid field.

Parameters

rlim	pair of r bounds
zlim	pair of z bounds
nbins	pair of bin counts
field	the solenoid field instance

Returns

A field map instance for use in interpolation.

Definition at line 256 of file BFieldMapUtils.cpp.

View newest version in sPHENIX GitHub at line 256 of file BFieldMapUtils.cpp

References Acts::SolenoidBField::getField(), grid(), i, index, j, std::tr1::make_tuple(), Acts::UnitConstants::min, testing::internal::move(), nbins, Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), and Acts::Test::pos.

Referenced by Acts::Python::addMagneticField(), main(), Acts::IntegrationTest::makeFieldMap(), and ActsExamples::Options::readMagneticField().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::sortDetElementsByID ( std::vector< dd4hep::DetElement > &  det )

inline

Sort function which sorts dd4hep::DetElement by their ID

Parameters

[in,out]

det

the dd4hep::DetElements to be sorted

Definition at line 37 of file ConvertDD4hepDetector.hpp.

View newest version in sPHENIX GitHub at line 37 of file ConvertDD4hepDetector.hpp

References KFPMath::a, KFPMath::b, and Acts::Experimental::detail::BlueprintHelper::sort().

Here is the call graph for this function:

std::shared_ptr<Surface> Acts::surfaceFromJson

(

const nlohmann::json &

j

)

Conversion to Surface from jsonn

Parameters

j	the read-in json object

Returns

a shared_ptr to a surface object for type polymorphism

template<typename surface_t , typename bounds_t >

std::shared_ptr<surface_t> Acts::surfaceFromJsonT

(

const nlohmann::json &

j

)

Conversion to Surface from json in correct type

The type is given as a template argument in order to be able to construct the correct fitting types for surfaces.

Parameters

j	the read-in json object

Returns

a shared_ptr to a typed surface object for type polymorphism

Definition at line 73 of file SurfaceJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 73 of file SurfaceJsonConverter.hpp

References Acts::Transform3JsonConverter::fromJson(), testing::internal::move(), and sTransform.

Here is the call graph for this function:

template<template< size_t > class Callable, size_t N, size_t NMAX, typename... Args>

auto Acts::template_switch	(	size_t	v,
		Args &&...	args
	)

Dispatch a call based on a runtime value on a function taking the value at compile time.

This function allows to write a templated functor, which accepts a size_t like parameter at compile time. It is then possible to make a call to the corresponding instance of the functor based on a runtime value. To achieve this, the function essentially created a if cascade between N and NMAX, attempting to find the right instance. Because the cascade is visible to the compiler entirely, it should be able to optimize.

Template Parameters

Callable	Type which takes a size_t as a compile time param
N	Value from which to start the dispatch chain, i.e. 0 in most cases
NMAX	Maximum value up to which to attempt a dispatch

Parameters

v	The runtime value to dispatch on
args	Additional arguments passed to Callable::invoke().

Note

Callable is expected to have a static member function invoke that is callable with Args

Definition at line 110 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 110 of file Helpers.hpp

References check_smearing_config::args, N, NMAX, and testSigmaEff::v.

template<size_t N, size_t NMAX, typename Lambda , typename... Args>

auto Acts::template_switch_lambda	(	size_t	v,
		Lambda &&	func,
		Args &&...	args
	)

Alternative version of template_switch which accepts a generic lambda and communicates the dimension via an integral constant type

Template Parameters

N	Value from which to start the dispatch chain, i.e. 0 in most cases
NMAX	Maximum value up to which to attempt a dispatch

Parameters

v	The runtime value to dispatch on
func	The lambda to invoke
args	Additional arguments passed to func

Definition at line 136 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 136 of file Helpers.hpp

References check_smearing_config::args, N, NMAX, and testSigmaEff::v.

template<std::size_t kDIM, typename value_type >

std::array<value_type, kDIM> Acts::to_array

(

const std::vector< value_type > &

vecvals

)

This can be abandoned with C++20 to use the std::to_array method

Note

only the first kDIM elements will obviously be filled, if the vector tends to be longer, it is truncated

Parameters

vecvals

the vector of bound values to be converted

Returns

an array with the filled values

Definition at line 81 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 81 of file Helpers.hpp

References enumerate(), and testSigmaEff::v.

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const Transform3 &	t
	)

Definition at line 14 of file AlgebraJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 14 of file AlgebraJsonConverter.cpp

References translation().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const Extent &	e
	)

Definition at line 22 of file ExtentJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 22 of file ExtentJsonConverter.cpp

References binningValueNames(), Acts::Extent::constrains(), enumerate(), Acts::Extent::envelope(), add_histos_bX::ib, Acts::Extent::range(), s_binningValues, and zeroEnvelope.

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const ProtoVolume &	pv
	)

Helper m ethod to write binnings

Parameters

root	the json root into which this is written
binning	the vector of binning data
key	the key for the root writing

Definition at line 21 of file ProtoDetectorJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 21 of file ProtoDetectorJsonConverter.cpp

References Acts::ProtoVolume::container, Acts::ProtoVolume::extent, Acts::ProtoVolume::internal, Acts::ProtoVolume::name, and fixGDML::root.

void Acts::to_json	(	nlohmann::json &	j,
		const BinningData &	bd
	)

Definition at line 22 of file UtilitiesJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 22 of file UtilitiesJsonConverter.cpp

References arbitrary, bins, Acts::BinningData::bins(), Acts::BinningData::binvalue, Acts::BinningData::boundaries(), equidistant, Acts::BinningData::max, Acts::BinningData::min, open, Acts::BinningData::option, Acts::BinningData::subBinningAdditive, Acts::BinningData::subBinningData, to_json(), and Acts::BinningData::type.

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const ProtoDetector &	pd
	)

Definition at line 117 of file ProtoDetectorJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 117 of file ProtoDetectorJsonConverter.cpp

References Acts::ProtoDetector::name, and Acts::ProtoDetector::worldVolume.

void Acts::to_json	(	nlohmann::json &	j,
		const SurfaceBounds &	bounds
	)

Definition at line 14 of file SurfaceBoundsJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 14 of file SurfaceBoundsJsonConverter.cpp

References Acts::SurfaceBounds::type(), and Acts::SurfaceBounds::values().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const Material &	t
	)

Definition at line 37 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 37 of file MaterialJsonConverter.cpp

References i, and Acts::Material::parameters().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const BinUtility &	bu
	)

Definition at line 82 of file UtilitiesJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 82 of file UtilitiesJsonConverter.cpp

References Acts::BinUtility::binningData(), Acts::Transform3JsonConverter::toJson(), and Acts::BinUtility::transform().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const VolumeBounds &	bounds
	)

Definition at line 22 of file VolumeBoundsJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 22 of file VolumeBoundsJsonConverter.cpp

References Acts::VolumeBounds::type(), and Acts::VolumeBounds::values().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const MaterialSlab &	t
	)

Definition at line 60 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 60 of file MaterialJsonConverter.cpp

References Acts::MaterialSlab::material(), and Acts::MaterialSlab::thickness().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const TrackingVolumeAndMaterial &	volume
	)

Conversion of a pair of tracking volume and material used for the material mapping

Definition at line 15 of file VolumeJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 15 of file VolumeJsonConverter.cpp

References Acts::jsonKey::namekey, and to_json().

Here is the call graph for this function:

template<typename Type >

void Acts::to_json	(	nlohmann::json &	j,
		const Range1D< Type > &	r
	)

Definition at line 35 of file UtilitiesJsonConverter.hpp.

View newest version in sPHENIX GitHub at line 35 of file UtilitiesJsonConverter.hpp

References Acts::Range1D< Type >::max(), and Acts::Range1D< Type >::min().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const SurfaceAndMaterialWithContext &	surface
	)

Conversion of a pair of surface and material used for the material mapping.

Definition at line 34 of file SurfaceJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 34 of file SurfaceJsonConverter.cpp

References to_json(), and Acts::Transform3JsonConverter::toJson().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const TrackingVolumePointer &	volume
	)

Conversion of a tracking volume.

Conversion of a const pointer on a tracking volume used to write the geometry

Definition at line 21 of file VolumeJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 21 of file VolumeJsonConverter.cpp

References to_json().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const volumeMaterialPointer &	material
	)

Definition at line 202 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 202 of file MaterialJsonConverter.cpp

References TauVsDIS_MachineLearning_Differentiation::array, Acts::jsonKey::binkey, Acts::BinUtility::binningData(), bins, Acts::jsonKey::datakey, configureMap::ibin, Acts::jsonKey::mapkey, material, Acts::jsonKey::materialkey, and Acts::jsonKey::typekey.

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const Acts::TGeoCylinderDiscSplitter::Config &	cdc
	)

Write config for cylinder/disc module splitter.

Definition at line 38 of file JsonTGeoDetectorConfig.hpp.

View newest version in sPHENIX GitHub at line 38 of file JsonTGeoDetectorConfig.hpp

References Acts::TGeoCylinderDiscSplitter::Config::cylinderLongitudinalSegments, Acts::TGeoCylinderDiscSplitter::Config::cylinderPhiSegments, Acts::TGeoCylinderDiscSplitter::Config::discPhiSegments, and Acts::TGeoCylinderDiscSplitter::Config::discRadialSegments.

Referenced by BOOST_AUTO_TEST_CASE(), ActsExamples::to_json(), to_json(), and ActsExamples::writeJsonGeometryList().

Here is the caller graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const Surface &	surface
	)

Non-contextual conversion of a surface

Note

it will take the default context

Definition at line 40 of file SurfaceJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 40 of file SurfaceJsonConverter.cpp

References gctx, and Acts::Transform3JsonConverter::toJson().

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const surfaceMaterialPointer &	material
	)

Definition at line 83 of file MaterialJsonConverter.cpp.

View newest version in sPHENIX GitHub at line 83 of file MaterialJsonConverter.cpp

References TauVsDIS_MachineLearning_Differentiation::array, Acts::jsonKey::binkey, Acts::BinUtility::binningData(), bins, Acts::jsonKey::datakey, configureMap::ibin, Acts::jsonKey::mapkey, Acts::ISurfaceMaterial::mappingType(), Acts::jsonKey::maptype, material, Acts::jsonKey::materialkey, testing::internal::move(), and Acts::jsonKey::typekey.

Here is the call graph for this function:

void Acts::to_json	(	nlohmann::json &	j,
		const std::shared_ptr< const Surface > &	surface
	)

Non-contextual conversion of a surface

Note

it will take the default context

void Acts::toJson	(	nlohmann::json &	j,
		const std::shared_ptr< const Surface > &	surface,
		const Acts::GeometryContext &	gctx
	)

Contextual conversion of a surface

Parameters

j	the json to be filled
surface	the surface to be converted
gctx	the geometry context for this

template<typename derived_t >

std::string Acts::toString ( const Eigen::MatrixBase< derived_t > &  matrix, int  precision = 4, const std::string &  offset = ""  )

inline

Print out a matrix in a structured way.

Template Parameters

derived_t

Type of the matrix

Parameters

matrix	The matrix to print
precision	Numeric output precision
offset	Offset in front of matrix lines

Returns

The printed string

Definition at line 38 of file StringHelpers.hpp.

View newest version in sPHENIX GitHub at line 38 of file StringHelpers.hpp

References i, j, offset, precision, and Acts::detail::roundWithPrecision().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Experimental::VolumeStructureBuilder::construct(), toString(), and ActsExamples::SvgPointWriter< T, Acc >::writeT().

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Acts::toString ( const Acts::Translation3 &  translation, int  precision = 4  )

inline

Print out a translation in a structured way.

Parameters

translation	The translation to print
precision	Numeric output precision

Returns

The printed string

Definition at line 81 of file StringHelpers.hpp.

View newest version in sPHENIX GitHub at line 81 of file StringHelpers.hpp

References precision, and toString().

Here is the call graph for this function:

std::string Acts::toString ( const Acts::Transform3 &  transform, int  precision = 4, const std::string &  offset = ""  )

inline

Print out a transform in a structured way.

Parameters

transform	The transform to print
precision	Numeric output precision
offset	Offset in front of matrix lines

Returns

The printed string

Definition at line 95 of file StringHelpers.hpp.

View newest version in sPHENIX GitHub at line 95 of file StringHelpers.hpp

References offset, precision, and toString().

Here is the call graph for this function:

template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >

Acts::TrackContainer	(	track_container_t &	container,
		traj_t &	traj
	)		-> TrackContainer< track_container_t, traj_t, detail::RefHolder >

template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >

Acts::TrackContainer	(	const track_container_t &	container,
		const traj_t &	traj
	)		-> TrackContainer< track_container_t, traj_t, detail::ConstRefHolder >

template<ACTS_CONCEPT(TrackContainerBackend) track_container_t, typename traj_t >

Acts::TrackContainer	(	track_container_t &&	container,
		traj_t &&	traj
	)		-> TrackContainer< track_container_t, traj_t, detail::ValueHolder >

std::shared_ptr<const TrackingGeometry> Acts::trackingGeometry

(

)

create a small tracking geometry to map some dummy material on

Definition at line 40 of file SurfaceMaterialMapperTests.cpp.

View newest version in sPHENIX GitHub at line 40 of file SurfaceMaterialMapperTests.cpp

References binZ, getDefaultLogger(), Acts::Logging::INFO, Acts::CylinderVolumeHelper::Config::layerArrayCreator, Acts::PassiveLayerBuilder::Config::layerIdentification, open, Acts::LayerCreator::Config::surfaceArrayCreator, and Acts::CylinderVolumeBuilder::Config::trackingVolumeHelper.

Referenced by Acts::Python::addPropagation(), Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), runDetectorAlignment(), runRecCKFTracks(), and runRecTruthTracks().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename external_spacepoint_t >

LinCircle Acts::transformCoordinates ( const InternalSpacePoint< external_spacepoint_t > &  sp, const InternalSpacePoint< external_spacepoint_t > &  spM, bool  bottom  )

inline

Transform two spacepoints to a u-v space circle.

This function is a non-vectorized version of transformCoordinates.

Template Parameters

external_spacepoint_t

The external spacepoint type.

Parameters

[in]	sp	The first spacepoint to use, either a bottom or top.
[in]	spM	The middle spacepoint to use.
[in]	bottom	Should be true if sp is a bottom SP.

Definition at line 11 of file SeedFinderUtils.ipp.

View newest version in sPHENIX GitHub at line 11 of file SeedFinderUtils.ipp

References testing::internal::move(), and check_smearing_config::output.

Referenced by Acts::SeedFinderOrthogonal< external_spacepoint_t >::filterCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename external_spacepoint_t , typename callable_t >

LinCircle Acts::transformCoordinates ( const external_spacepoint_t &  sp, const external_spacepoint_t &  spM, bool  bottom, callable_t &&  extractFunction  )

inline

Definition at line 27 of file SeedFinderUtils.ipp.

View newest version in sPHENIX GitHub at line 27 of file SeedFinderUtils.ipp

template<typename external_spacepoint_t >

void Acts::transformCoordinates ( Acts::SpacePointData &  spacePointData, const std::vector< InternalSpacePoint< external_spacepoint_t > * > &  vec, const InternalSpacePoint< external_spacepoint_t > &  spM, bool  bottom, std::vector< LinCircle > &  linCircleVec  )

inline

Transform a vector of spacepoints to u-v space circles with respect to a given middle spacepoint.

Template Parameters

external_spacepoint_t

The external spacepoint type.

Parameters

[in]	spacePointData	Auxiliary variables used by the seeding
[in]	vec	The list of bottom or top spacepoints
[in]	spM	The middle spacepoint.
[in]	bottom	Should be true if vec are bottom spacepoints.
[out]	linCircleVec	The output vector to write to.

Definition at line 69 of file SeedFinderUtils.ipp.

View newest version in sPHENIX GitHub at line 69 of file SeedFinderUtils.ipp

References testing::internal::move(), check_smearing_config::output, and vec.

Here is the call graph for this function:

template<typename external_spacepoint_t , typename callable_t >

void Acts::transformCoordinates ( Acts::SpacePointData &  spacePointData, const std::vector< external_spacepoint_t * > &  vec, const external_spacepoint_t &  spM, bool  bottom, std::vector< LinCircle > &  linCircleVec, callable_t &&  extractFunction  )

inline

Definition at line 88 of file SeedFinderUtils.ipp.

View newest version in sPHENIX GitHub at line 88 of file SeedFinderUtils.ipp

References ambiguity_solver_full_chain::idx, and Acts::SpacePointData::setDeltaR().

Here is the call graph for this function:

std::tuple< Acts::VariantCovariance, Acts::VariantTransportJacobian > Acts::transportCovarianceToBound	(	const GeometryContext &	gctx,
		const Surface &	surface,
		const FreeVector &	parameters,
		CovarianceCache &	cCache
	)

Transport the covariance to a new (surface) bound definition

Parameters

gctx	[in] The current geometry context
surface	[in] The surface of the bound representation
parameters	[in] The free parametrisation on the surface
cCache	[in,out] the covariance cache (to be modified)

Returns

a variant transport jacobian

Definition at line 42 of file CovarianceTransport.cpp.

View newest version in sPHENIX GitHub at line 42 of file CovarianceTransport.cpp

References Acts::CovarianceCache::anglesToDirectionJacobian, Acts::detail::boundToBoundTransportJacobian(), Acts::CovarianceCache::boundToFreeJacobian, Acts::CovarianceCache::covariance, covariance(), Acts::CovarianceCache::directionToAnglesJacobian, Acts::detail::freeToBoundTransportJacobian(), Acts::CovarianceCache::freeToPathDerivatives, Acts::CovarianceCache::freeTransportJacobian, and writeMapConfig::surface.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::EDM4hepUtil::detail::convertTrackParametersToEdm4hep(), main(), and Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::transportCovarianceToBound().

Here is the call graph for this function:

Here is the caller graph for this function:

std::tuple< Acts::VariantCovariance, Acts::VariantTransportJacobian > Acts::transportCovarianceToCurvilinear	(	const Vector3 &	direction,
		CovarianceCache &	cCache
	)

Transport the covariance to a new (curvilinear) bound definition

Parameters

direction	[in] The track direction at the new curvilinear definition
cCache	[in,out] the covariance cache (to be modified)

Definition at line 71 of file CovarianceTransport.cpp.

View newest version in sPHENIX GitHub at line 71 of file CovarianceTransport.cpp

References Acts::CovarianceCache::anglesToDirectionJacobian, Acts::detail::boundToCurvilinearTransportJacobian(), Acts::CovarianceCache::boundToFreeJacobian, Acts::CovarianceCache::covariance, covariance(), Acts::CovarianceCache::directionToAnglesJacobian, Acts::detail::freeToCurvilinearTransportJacobian(), Acts::CovarianceCache::freeToPathDerivatives, and Acts::CovarianceCache::freeTransportJacobian.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >::transportCovarianceToCurvilinear().

Here is the call graph for this function:

Here is the caller graph for this function:

std::tuple< Acts::VariantCovariance, Acts::VariantTransportJacobian > Acts::transportCovarianceToFree

(

CovarianceCache &

cCache

)

Transport the covariance to a new free definition

Parameters

cCache

[in,out] the covariance cache (to be modified)

Definition at line 99 of file CovarianceTransport.cpp.

View newest version in sPHENIX GitHub at line 99 of file CovarianceTransport.cpp

References Acts::CovarianceCache::anglesToDirectionJacobian, Acts::CovarianceCache::boundToFreeJacobian, Acts::detail::boundToFreeTransportJacobian(), Acts::CovarianceCache::covariance, covariance(), Acts::CovarianceCache::directionToAnglesJacobian, Acts::detail::freeToFreeTransportJacobian(), and Acts::CovarianceCache::freeTransportJacobian.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

std::vector<const T*> Acts::unpack_shared_const_vector

(

const std::vector< std::shared_ptr< T >> &

items

)

Helper function to unpack a vector of shared_ptr into a vector of raw pointers

Template Parameters

T	the stored type

Parameters

items

The vector of shared_ptr

Returns

The unpacked vector

Definition at line 63 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 63 of file Helpers.hpp

References merge_hashes::items.

Referenced by Acts::Experimental::detail::PortalHelper::attachDetectorVolumesUpdator(), Acts::Experimental::detail::PortalHelper::attachDetectorVolumeUpdators(), and Acts::Experimental::DetectorVolume::ObjectStore< std::shared_ptr< DetectorVolume > >::ObjectStore().

Here is the caller graph for this function:

template<typename T >

std::vector<T*> Acts::unpack_shared_vector

(

const std::vector< std::shared_ptr< T >> &

items

)

Helper function to unpack a vector of shared_ptr into a vector of raw pointers

Template Parameters

T	the stored type

Parameters

items

The vector of shared_ptr

Returns

The unpacked vector

Definition at line 31 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 31 of file Helpers.hpp

References merge_hashes::items.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_FIXTURE_TEST_CASE(), Acts::TGeoLayerBuilder::buildLayers(), Acts::GenericApproachDescriptor::GenericApproachDescriptor(), Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(), Acts::SurfaceArrayCreator::surfaceArrayOnDisc(), and Acts::SurfaceArrayCreator::surfaceArrayOnPlane().

Here is the caller graph for this function:

template<typename T >

std::vector<const T*> Acts::unpack_shared_vector

(

const std::vector< std::shared_ptr< const T >> &

items

)

Helper function to unpack a vector of shared_ptr into a vector of raw pointers (const version)

Template Parameters

T	the stored type

Parameters

items

The vector of shared_ptr

Returns

The unpacked vector

Definition at line 47 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 47 of file Helpers.hpp

References merge_hashes::items.

template<typename L , typename A , typename B >

auto Acts::visit_measurement	(	A &&	param,
		B &&	cov,
		size_t	dim,
		L &&	lambda
	)

Dispatch a lambda call on an overallocated parameter vector and covariance matrix, based on a runtime dimension value. Inside the lambda call, the vector and matrix will have fixed dimensions, but will still point back to the originally given overallocated values.

Template Parameters

L	The lambda type
A	The parameter vector type
B	The covariance matrix type

Note

No requirements on A and B are made, to enable a single overload for both const and non-const matrices/vectors.

Parameters

param	The parameter vector
cov	The covariance matrix
dim	The actual dimension as a runtime value
lambda	The lambda to call with the statically sized subsets

Definition at line 55 of file MeasurementHelpers.hpp.

View newest version in sPHENIX GitHub at line 55 of file MeasurementHelpers.hpp

References Acts::Test::cov, and Acts::Test::dim.

Referenced by BOOST_AUTO_TEST_CASE(), Acts::MeasurementSelector::calculateChi2(), Acts::detail::calculateDeterminant(), ActsExamples::RefittingCalibrator::calibrate(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::copyFrom(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::effectiveCalibrated(), Acts::detail_lt::TrackStateProxy< trajectory_t, M, ReadOnly >::effectiveCalibratedCovariance(), ResidualOutlierFinder::operator()(), Acts::Test::MultiTrajectoryTestsCommon< factory_t >::testTrackStateProxyCopy(), Acts::Test::MultiTrajectoryTestsCommon< factory_t >::testTrackStateProxyStorage(), and Acts::GainMatrixUpdater::visitMeasurement().

Here is the caller graph for this function:

template<typename L >

auto Acts::visit_measurement	(	size_t	dim,
		L &&	lambda
	)

Dispatch a generic lambda on a measurement dimension. This overload doesn't assume anything about what is needed inside the lambda, it communicates the dimension via an integral constant type

Template Parameters

L	The generic lambda type to call

Parameters

dim	The runtime dimension of the measurement
lambda	The generic lambda instance to call

Returns

Returns the lambda return value

Definition at line 68 of file MeasurementHelpers.hpp.

View newest version in sPHENIX GitHub at line 68 of file MeasurementHelpers.hpp

References Acts::Test::dim.

std::shared_ptr< const CylinderVolumeBuilder > Acts::volumeBuilder_dd4hep	(	dd4hep::DetElement	subDetector,
		const Logger &	logger,
		BinningType	bTypePhi = equidistant,
		BinningType	bTypeR = equidistant,
		BinningType	bTypeZ = equidistant,
		double	layerEnvelopeR = UnitConstants::mm,
		double	layerEnvelopeZ = UnitConstants::mm,
		double	defaultLayerThickness = UnitConstants::fm
	)

Method internally used to create an Acts::CylinderVolumeBuilder.

This method creates an Acts::CylinderVolumeBuilder from a sub detector (= 'compound' DetElement or DetElements which are declared as 'isBarrel' or 'isBeampipe' by their extension.

Parameters

[in]	subDetector	the DD4hep DetElement of the subdetector
[in]	logger	A logger instance
[in]	bTypePhi	is how the sensitive surfaces (modules) should be binned in a layer in phi direction.

Note

Possible binningtypes:

• arbitrary - of the sizes if the surfaces and the distance in between vary. This mode finds out the bin boundaries by scanning through the surfaces.
• equidistant - if the sensitive surfaces are placed equidistantly

equidistant binningtype is recommended because it is faster not only while building the geometry but also for look up during the extrapolation

Parameters

[in]	bTypeR	is how the sensitive surfaces (modules) should be binned in a layer in r direction
[in]	bTypeZ	is how the sensitive surfaces (modules) should be binned in a layer in z direction
[in]	layerEnvelopeR	the tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
[in]	layerEnvelopeZ	the tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
[in]	defaultLayerThickness	In case no surfaces (to be contained by the layer) are handed over, the layer thickness will be set to this value

Note

Layers containing surfaces per default are not allowed to be attached to each other (navigation will fail at this point). However, to allow material layers (not containing surfaces) to be attached to each other, this default thickness is needed. In this way, the layer will be thin (with space to the next layer), but the material will have the 'real' thickness.

Attention

The default thickness should be set thin enough that no touching or overlapping with the next layer can happen.

Returns

std::shared_ptr the Acts::CylinderVolumeBuilder which can be used to build the full tracking geometry

the dd4hep::DetElements of the layers of the negative volume

the dd4hep::DetElements of the layers of the central volume

the dd4hep::DetElements of the layers of the positive volume

the dd4hep::DetElements of the layers of the central volume

the dd4hep::DetElements of the layers of the negative volume

the dd4hep::DetElements of the layers of the central volume

the dd4hep::DetElements of the layers of the positive volume

the dd4hep::DetElements of the layers of the central volume

Definition at line 156 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 156 of file ConvertDD4hepDetector.cpp

References ACTS_INFO, ACTS_VERBOSE(), Acts::CylinderVolumeBuilder::Config::boundaryMaterial, Acts::CylinderVolumeBuilder::Config::buildToRadiusZero, Acts::PassiveLayerBuilder::Config::centralLayerHalflengthZ, Acts::PassiveLayerBuilder::Config::centralLayerMaterial, Acts::PassiveLayerBuilder::Config::centralLayerRadii, Acts::PassiveLayerBuilder::Config::centralLayerThickness, Acts::DD4hepVolumeBuilder::Config::centralVolumes, Acts::Logger::clone(), closed, Acts::UnitConstants::cm, collectCompounds_dd4hep(), collectLayers_dd4hep(), Acts::DD4hepLayerBuilder::Config::configurationName, Acts::DD4hepVolumeBuilder::Config::configurationName, createProtoMaterial(), Acts::CylinderVolumeBuilder::Config::ctVolumeBuilder, cylinderVolumeHelper_dd4hep(), getParams(), hasParam(), Acts::CylinderVolumeBuilder::Config::layerBuilder, Acts::CylinderVolumeBuilder::Config::layerEnvelopeR, Acts::CylinderVolumeBuilder::Config::layerEnvelopeZ, Acts::PassiveLayerBuilder::Config::layerIdentification, logger(), open, Acts::LayerCreator::Config::surfaceArrayCreator, Acts::CylinderVolumeBuilder::Config::trackingVolumeHelper, type, Acts::CylinderVolumeBuilder::Config::volumeName, and Acts::CylinderVolumeBuilder::Config::volumeSignature.

Referenced by convertDD4hepDetector().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename external_spacepoint_t >

bool Acts::xyzCoordinateCheck ( Acts::SpacePointData &  spacePointData, const Acts::SeedFinderConfig< external_spacepoint_t > &  config, const Acts::InternalSpacePoint< external_spacepoint_t > &  sp, const double *  spacepointPosition, double *  outputCoordinates  )

inline

Check the compatibility of spacepoint coordinates in xyz assuming the Bottom-Middle direction with the strip meassument details.

Template Parameters

external_spacepoint_t

The external spacepoint type.

Parameters

[in]	spacePointData	Auxiliary variables used by the seeding
[in]	config	SeedFinder config containing the delegates to the strip measurement details.
[in]	sp	Input space point used in the check.
[in]	spacepointPosition	Spacepoint coordinates in xyz plane.
[out]	outputCoordinates	The output vector to write to.

Returns

Boolean that says if spacepoint is compatible with being inside the detector element.

Definition at line 151 of file SeedFinderUtils.ipp.

View newest version in sPHENIX GitHub at line 151 of file SeedFinderUtils.ipp

References Acts::SpacePointData::getBottomStripVector(), Acts::SpacePointData::getStripCenterDistance(), Acts::SpacePointData::getTopStripCenterPosition(), Acts::SpacePointData::getTopStripVector(), Acts::SpacePointData::hasDynamicVariable(), Acts::InternalSpacePoint< SpacePoint >::index(), index, and Acts::SeedFinderConfig< SpacePoint >::toleranceParam.

Referenced by Acts::SeedFinder< external_spacepoint_t, platform_t >::filterCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename... R>

auto Acts::zip

(

R &&...

r

)

Function that allows to zip some ranges to be used in a range-based for loop. When wanting to mutate the entries, the result must be captured by value:

for(auto [a, b, c] : zip(ra, rb, rc)) { a+=2; }

Template Parameters

R	The ranges type pack

Parameters

r	The ranges parameter pack

Note

the behaviour is undefined if the ranges do not have equal range

Definition at line 25 of file Zip.hpp.

View newest version in sPHENIX GitHub at line 25 of file Zip.hpp

References check_smearing_config::args, KFPMath::b, parse_cmake_options::begin, Acts::UnitConstants::e, end, std::tr1::make_tuple(), operator!=(), operator*(), and physmon_track_finding_ttbar::r.

Referenced by TPC_Cluster_Drift_Animator::animate_scatters(), TPC_Cluster_Drift_Animator_beam::animate_scatters(), train_ambiguity_solver::batchSplit(), smearing-config::block_to_json(), BOOST_AUTO_TEST_CASE(), root_event_diff_np::cmp(), acts.examples::ConcretePropagator(), Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::convoluteComponents(), ActsExamples::TrackFindingAlgorithmExaTrkX::execute(), RecoPV_optimization::get2DTable(), helpers.hash_root::hash_root_file(), vertex_mu_scan::main(), make_inp_lists::main(), Acts::BoostTrackBuilding::operator()(), quick_view::plot(), train_ambiguity_solver::scoringBatch(), and Acts::detail::GsfActor< bethe_heitler_approx_t, traj_t >::updateStepper().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

std::vector<std::tuple<std::string, BinningValue> > Acts::allowedBinnings

static

Initial value:

= {
    {"x", binX}, {"y", binY}, {"z", binZ}, {"phi", binPhi}, {"r", binR}}

Definition at line 30 of file DD4hepBinningHelpers.hpp.

View newest version in sPHENIX GitHub at line 30 of file DD4hepBinningHelpers.hpp

Referenced by convertBinning().

Transform3 Acts::aTransform

Initial value:

= Transform3::Identity() *
                        Translation3(30_cm, 7_m, -87_mm) *
                        AngleAxis3(0.42, Vector3(-3., 1., 8).normalized())

Definition at line 38 of file SurfaceIntersectionTests.cpp.

View newest version in sPHENIX GitHub at line 38 of file SurfaceIntersectionTests.cpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), main(), and ActsExamples::Contextual::InternallyAlignedDetectorElement::transform().

Acts::else

Initial value:

{
    ifj >> jin

Definition at line 44 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 44 of file JsonMaterialDecorator.cpp

nlohmann::json Acts::jin

Definition at line 38 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 38 of file JsonMaterialDecorator.cpp

constexpr TrackIndexType Acts::kTrackIndexInvalid

static

Initial value:

=
    std::numeric_limits<TrackIndexType>::max()

Definition at line 16 of file Types.hpp.

View newest version in sPHENIX GitHub at line 16 of file Types.hpp

template<typename fitter >

constexpr bool Acts::LinearizerConcept

Initial value:

=
    Acts::Concepts ::Linearizer::LinearizerConcept<fitter>::value

Definition at line 62 of file LinearizerConcept.hpp.

View newest version in sPHENIX GitHub at line 62 of file LinearizerConcept.hpp

Acts::m_surfaceMaterialMap = maps.first

Definition at line 49 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 49 of file JsonMaterialDecorator.cpp

Referenced by while().

Acts::m_volumeMaterialMap = maps.second

Definition at line 50 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 50 of file JsonMaterialDecorator.cpp

Referenced by while().

auto Acts::maps = jmConverter.jsonToMaterialMaps(jin)

Definition at line 48 of file JsonMaterialDecorator.cpp.

View newest version in sPHENIX GitHub at line 48 of file JsonMaterialDecorator.cpp

Referenced by TrkrNtuplizer::fillOutputNtuples(), SvtxEvaluator::fillOutputNtuples(), Acts::MaterialMapJsonConverter::jsonToMaterialMaps(), and detail::readMaps().

constexpr size_t Acts::MAX_SEG_PER_NODE = 1000

Definition at line 21 of file GNN_DataStorage.hpp.

View newest version in sPHENIX GitHub at line 21 of file GNN_DataStorage.hpp

Referenced by Acts::TrigFTF_GNN_Node< external_spacepoint_t >::addIn(), Acts::TrigFTF_GNN_Node< external_spacepoint_t >::addOut(), Acts::TrigFTF_GNN_Node< external_spacepoint_t >::isFull(), and Acts::SeedFinderFTF< external_spacepoint_t >::runGNN_TrackFinder().

constexpr size_t Acts::N_SEG_CONNS = 6

Definition at line 22 of file GNN_DataStorage.hpp.

View newest version in sPHENIX GitHub at line 22 of file GNN_DataStorage.hpp

Referenced by Acts::SeedFinderFTF< external_spacepoint_t >::runGNN_TrackFinder().

constexpr int Acts::PolygonDynamic = -1

Tag to trigger specialization of a dynamic polygon.

Definition at line 137 of file ConvexPolygonBounds.hpp.

View newest version in sPHENIX GitHub at line 137 of file ConvexPolygonBounds.hpp

const std::vector<BinningValue> Acts::s_binningValues

static

Initial value:

= {
    binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta, binMag}

static list of all binning values

Definition at line 49 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 49 of file BinningType.hpp

Referenced by Acts::Extent::addConstrain(), Acts::ProtoVolume::harmonize(), isEqual(), and to_json().

constexpr ActsScalar Acts::s_curvilinearProjTolerance = 0.999995

static

Tolerance for not being within curvilinear projection this allows using the same curvilinear frame to eta = 6, validity tested with IntegrationTests/PropagationTest

Definition at line 31 of file Tolerance.hpp.

View newest version in sPHENIX GitHub at line 31 of file Tolerance.hpp

Referenced by Acts::detail::freeToCurvilinearJacobian(), and Acts::PlaneSurface::PlaneSurface().

constexpr ActsScalar Acts::s_epsilon

static

Initial value:

=
    3 * std::numeric_limits<ActsScalar>::epsilon()

Tolerance for being numerical equal for geometry building.

Definition at line 18 of file Tolerance.hpp.

View newest version in sPHENIX GitHub at line 18 of file Tolerance.hpp

Referenced by Acts::Test::basicChecks(), Acts::MappingMaterialDecorator::binnedSurfaceMaterial(), BOOST_AUTO_TEST_CASE(), ActsFatras::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::Layers::BOOST_AUTO_TEST_CASE(), Acts::CutoutCylinderVolumeBounds::buildSurfaceBounds(), Acts::CylinderVolumeBounds::buildSurfaceBounds(), Acts::ConeVolumeBounds::buildSurfaceBounds(), Acts::ConeBounds::checkConsistency(), Acts::AnnulusBounds::checkConsistency(), Acts::TGeoSurfaceConverter::cylinderComponents(), Acts::TGeoSurfaceConverter::discComponents(), Acts::detail::IntersectionHelper2D::intersectEllipse(), Acts::detail::IntersectionHelper2D::intersectSegment(), Acts::SurfaceMaterialMapper::mapInteraction(), Acts::VolumeMaterialMapper::mapMaterialTrack(), Acts::TGeoSurfaceConverter::planeComponents(), Acts::PlaneSurface::polyhedronRepresentation(), and ActsFatras::PlanarSurfaceMask::radialMask().

constexpr std::uint8_t Acts::s_maximumNumberOfIntersections = 2

static

Definition at line 115 of file Intersection.hpp.

View newest version in sPHENIX GitHub at line 115 of file Intersection.hpp

const InfiniteBounds Acts::s_noBounds {}

static

Definition at line 49 of file InfiniteBounds.hpp.

View newest version in sPHENIX GitHub at line 49 of file InfiniteBounds.hpp

Referenced by Acts::SurfaceStub::bounds(), Acts::PlaneSurface::bounds(), and Acts::LineSurface::bounds().

constexpr double Acts::s_normalizationTolerance = 1.e-4

static

The tolerated difference to 1 to accept weights as normalized.

Definition at line 32 of file GsfUtils.hpp.

View newest version in sPHENIX GitHub at line 32 of file GsfUtils.hpp

constexpr ActsScalar Acts::s_onSurfaceTolerance = 1e-4

static

Tolerance for being on Surface

Note

This is intentionally given w/o an explicit unit to avoid having to include the units header unnecessarily. With the native length unit of mm this corresponds to 0.1um.

Definition at line 26 of file Tolerance.hpp.

View newest version in sPHENIX GitHub at line 26 of file Tolerance.hpp

Referenced by Acts::Test::Layers::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), Acts::TrackingVolume::compatibleBoundaries(), Acts::Layer::compatibleSurfaces(), Acts::AnnulusBounds::coversFullAzimuth(), Acts::detail::VerticesHelper::ellipsoidVertices(), Acts::Experimental::detail::BlueprintHelper::fillGaps(), Acts::CylinderSurface::globalToLocal(), Acts::ConeVolumeBounds::inside(), Acts::CylinderBounds::inside3D(), ActsFatras::BoundParametersSmearer< RandomEngine, kSmearDIM >::operator()(), Acts::Test::PropagatorState::Stepper::overstepLimit(), Acts::ConeSurface::polyhedronRepresentation(), Acts::Layer::surfaceOnApproach(), and Acts::Experimental::updateCandidates().

const Transform3 Acts::s_planeXY = Transform3::Identity()

static

Definition at line 34 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 34 of file VolumeBounds.hpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE().

const Transform3 Acts::s_planeYZ

static

Initial value:

= AngleAxis3(0.5 * M_PI, Vector3::UnitY()) *
                                    AngleAxis3(0.5 * M_PI, Vector3::UnitZ()) *
                                    Transform3::Identity()

Definition at line 35 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 35 of file VolumeBounds.hpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::CuboidVolumeBounds::orientedSurfaces(), and Acts::TrapezoidVolumeBounds::orientedSurfaces().

const Transform3 Acts::s_planeZX

static

Initial value:

= AngleAxis3(-0.5 * M_PI, Vector3::UnitX()) *
                                    AngleAxis3(-0.5 * M_PI, Vector3::UnitZ()) *
                                    Transform3::Identity()

Definition at line 38 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 38 of file VolumeBounds.hpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::CuboidVolumeBounds::orientedSurfaces(), and Acts::TrapezoidVolumeBounds::orientedSurfaces().

ViewConfig Acts::s_viewFiltered = ViewConfig({255, 255, 0})

static

Definition at line 38 of file EventDataView3D.hpp.

View newest version in sPHENIX GitHub at line 38 of file EventDataView3D.hpp

ViewConfig Acts::s_viewGrid = ViewConfig({220, 0, 0})

static

Definition at line 37 of file GeometryView3D.hpp.

View newest version in sPHENIX GitHub at line 37 of file GeometryView3D.hpp

ViewConfig Acts::s_viewLine = ViewConfig({0, 0, 220})

static

Definition at line 38 of file GeometryView3D.hpp.

View newest version in sPHENIX GitHub at line 38 of file GeometryView3D.hpp

ViewConfig Acts::s_viewMeasurement = ViewConfig({255, 102, 0})

static

Definition at line 36 of file EventDataView3D.hpp.

View newest version in sPHENIX GitHub at line 36 of file EventDataView3D.hpp

ViewConfig Acts::s_viewParameter = ViewConfig({0, 0, 255})

static

Definition at line 35 of file EventDataView3D.hpp.

View newest version in sPHENIX GitHub at line 35 of file EventDataView3D.hpp

ViewConfig Acts::s_viewPassive = ViewConfig({240, 280, 0})

static

Definition at line 35 of file GeometryView3D.hpp.

View newest version in sPHENIX GitHub at line 35 of file GeometryView3D.hpp

ViewConfig Acts::s_viewPredicted = ViewConfig({51, 204, 51})

static

Definition at line 37 of file EventDataView3D.hpp.

View newest version in sPHENIX GitHub at line 37 of file EventDataView3D.hpp

ViewConfig Acts::s_viewSensitive = ViewConfig({0, 180, 240})

static

Definition at line 34 of file GeometryView3D.hpp.

View newest version in sPHENIX GitHub at line 34 of file GeometryView3D.hpp

Referenced by ActsExamples::MockupSectorBuilder::drawSector(), and Acts::SurfaceView3DTest::run().

ViewConfig Acts::s_viewSmoothed = ViewConfig({0, 102, 255})

static

Definition at line 39 of file EventDataView3D.hpp.

View newest version in sPHENIX GitHub at line 39 of file EventDataView3D.hpp

ViewConfig Acts::s_viewVolume = ViewConfig({220, 220, 0})

static

Definition at line 36 of file GeometryView3D.hpp.

View newest version in sPHENIX GitHub at line 36 of file GeometryView3D.hpp

Referenced by Acts::VolumeView3DTest::run().

template<typename accessor >

constexpr bool Acts::SourceLinkAccessorConcept

Initial value:

=
    Acts::Concepts ::SourceLinkAccessor::SourceLinkAccessorConcept<
        accessor>::value

Definition at line 76 of file SourceLinkAccessorConcept.hpp.

View newest version in sPHENIX GitHub at line 76 of file SourceLinkAccessorConcept.hpp

template<typename stepper , typename state = typename stepper::State>

constexpr bool Acts::StepperConcept

Initial value:

=
    Acts::Concepts ::Stepper::SingleStepperConcept<stepper, state>::value ||
    Acts::Concepts ::Stepper::MultiStepperConcept<stepper, state>::value

Definition at line 221 of file StepperConcept.hpp.

View newest version in sPHENIX GitHub at line 221 of file StepperConcept.hpp

template<typename stepper >

constexpr bool Acts::StepperStateConcept

Initial value:

=
    Acts::Concepts ::Stepper::StepperStateConcept<stepper> ||
    Acts::Concepts ::Stepper::MultiStepperStateConcept<stepper>

Definition at line 225 of file StepperConcept.hpp.

View newest version in sPHENIX GitHub at line 225 of file StepperConcept.hpp

GeometryContext Acts::tgContext = GeometryContext()

Definition at line 29 of file ConeVolumeBoundsTests.cpp.

View newest version in sPHENIX GitHub at line 29 of file ConeVolumeBoundsTests.cpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), Acts::Test::PropagatorState::Stepper::boundState(), Acts::Test::intersectionTest(), main(), Acts::Test::makeTrackingGeometry(), Acts::Test::runTest(), Acts::Test::testJacobianToGlobal(), Acts::EventDataView3DTest::testMeasurement(), and Acts::EventDataView3DTest::testMultiTrajectory().

std::shared_ptr<const TrackingGeometry> Acts::tGeometry = trackingGeometry()

Definition at line 105 of file SurfaceMaterialMapperTests.cpp.

View newest version in sPHENIX GitHub at line 105 of file SurfaceMaterialMapperTests.cpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), Acts::Test::makeTrackingGeometry(), TpcClusterQA::process_event(), processGeometry(), propagationExample(), runDigitizationExample(), runHoughExample(), runMaterialMapping(), runMeasurementsToSP(), runSeedingExample(), ActsGeometry::setGeometry(), and PHHybridSeeding::Setup().

Acts::type {typeIn}

Definition at line 55 of file FpeMonitor.cpp.

View newest version in sPHENIX GitHub at line 55 of file FpeMonitor.cpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), collectCompounds_dd4hep(), collectSubDetectors_dd4hep(), convertBinning(), Acts::CombinatorialKalmanFilter< propagator_t, traj_t >::Actor< source_link_accessor_t, parameters_t >::filter(), Acts::DetrayJsonHelper::maskFromBounds(), Acts::detail::MultiTrajectoryProjector< type, traj_t >::operator()(), Acts::detail::operator<<(), Acts::Surface::operator==(), Acts::ConstrainedStep::release(), test_components_modifying_accessors(), Acts::ConstrainedStep::update(), Acts::ConstrainedStep::value(), and volumeBuilder_dd4hep().

template<typename finder >

constexpr bool Acts::VertexFinderConcept

Initial value:

=
    Acts::Concepts ::VertexFinder::VertexFinderConcept<finder>::value

Definition at line 45 of file VertexFinderConcept.hpp.

View newest version in sPHENIX GitHub at line 45 of file VertexFinderConcept.hpp

template<typename fitter >

constexpr bool Acts::VertexFitterConcept

Initial value:

=
    Acts::Concepts ::VertexFitter::VertexFitterConcept<fitter>::value

Definition at line 64 of file VertexFitterConcept.hpp.

View newest version in sPHENIX GitHub at line 64 of file VertexFitterConcept.hpp

constexpr Envelope Acts::zeroEnvelope = {0, 0}

Definition at line 30 of file Extent.hpp.

View newest version in sPHENIX GitHub at line 30 of file Extent.hpp

Referenced by Acts::Extent::extend(), and to_json().

constexpr ExtentEnvelope Acts::zeroEnvelopes

Initial value:

= {
    zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope,
    zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope}

Definition at line 31 of file Extent.hpp.

View newest version in sPHENIX GitHub at line 31 of file Extent.hpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and BOOST_AUTO_TEST_CASE().