Acts Namespace Reference

Set the Geometry Context PLUGIN. More...

Namespaces
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 seperate file.
namespace	detail_lt
namespace	EventDataView3DTest
namespace	IntegrationTest
namespace	KalmanVertexTrackUpdater
namespace	KalmanVertexUpdater
namespace	Legacy
namespace	Logging
	debug output related helper classes and functions
namespace	MeasurementHelpers
namespace	MultiTrajectoryHelpers
namespace	PlanarHelper
	Helpers for planar surfaces that share the same maths.
namespace	PrimitivesView3DTest
namespace	SurfaceView3DTest
namespace	Sycl
namespace	Test
	Namespace for ATS unit tests.
namespace	TrackingGeometryView3DTest
namespace	UnitConstants
namespace	UnitLiterals
namespace	VectorHelpers
namespace	VolumeView3DTest

Classes
struct	Neutral
	Charge and momentum interpretation for neutral particles. More...
struct	SinglyCharged
	Charge and momentum interpretation for particles with +-e charge. More...
class	AnyCharge
class	Measurement
	base class for Measurements More...
struct	fittable_measurement_helper
struct	fittable_volume_measurement_helper
struct	MinimalSourceLink
class	MultiTrajectory
class	ParameterSet
	Description of a set of (local) parameters. More...
class	SingleBoundTrackParameters
class	SingleCurvilinearTrackParameters
class	SingleFreeTrackParameters
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
struct	Extent
class	GenericApproachDescriptor
class	GenericCuboidVolumeBounds
class	GeometryHierarchyMap
class	GeometryIdentifier
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	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
struct	InterpolatedBFieldMapper
	struct for mapping global 3D positions to field values More...
class	InterpolatedBFieldMap
	interpolate magnetic field value from field values on a given grid More...
exception	NullBField
	Null bfield which returns 0 always. More...
class	SharedBField
	allows to use a shared magnetic field in several places and with multiple steppers mainly targeted to save memory 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 (homogenous, 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
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...
struct	AbortList
	AbortList object to be used in the propagation. More...
struct	ActionList
	ActionList implementation to be used with the propagator. More...
class	AtlasStepper
	the AtlasStepper implementation for the More...
struct	ConstrainedStep
	A constrained step class for the steppers. More...
struct	DefaultExtension
	Default evaluater of the k_i's and elements of the transport matrix D of the RKN4 stepping. This is a pure implementation by textbook. More...
struct	DenseEnvironmentExtension
	Evaluater of the k_i's and elements of the transport matrix D of the RKN4 stepping. This implementation involves energy loss due to ioninisation, bremsstrahlung, pair production and photonuclear interaction in the propagation and the jacobian. These effects will only occur if the propagation is in a TrackingVolume with attached material. More...
struct	DenseStepperPropagatorOptions
class	DirectNavigator
class	EigenStepper
	Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE: More...
struct	MaterialInteraction
	The Material interaction struct It records the surface and the passed material This is only nessecary recorded when configured. More...
struct	MaterialInteractor
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	NeighborhoodIterator
class	Neighborhood
class	BinnedSPGroupIterator
class	BinnedSPGroup
class	IExperimentCuts
class	InternalSeed
class	InternalSpacePoint
class	Seed
class	SeedFilter
struct	SeedFilterConfig
struct	LinCircle
class	Seedfinder
struct	SeedfinderConfig
struct	SpacePointGridConfig
class	SpacePointGridCreator
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	SourceLinkSelectorCuts
struct	CKFSourceLinkSelector
	Source link selection struct selecting those source links compatible with the given track parameter against provided criteria on one surface. More...
struct	CombinatorialKalmanFilterTipState
	struct to keep record of the track quality More...
struct	CombinatorialKalmanFilterOptions
	Options struct how the CombinatorialKalmanFilter (CKF) is called. More...
struct	CombinatorialKalmanFilterResult
class	CombinatorialKalmanFilter
	CombinatorialKalmanFilter implementation of Acts as a plugin. More...
struct	VoidBranchStopper
	void branch stopper More...
struct	VoidKalmanComponents
	void Measurement calibrator and converter More...
struct	VoidMeasurementCalibrator
	Void measurement calibrator for filtering. More...
struct	VoidKalmanUpdater
	void Kalman updater More...
struct	VoidKalmanSmoother
	void Kalman smoother More...
struct	VoidOutlierFinder
	void outlier finder More...
class	GainMatrixSmoother
	Kalman smoother implementation based on Gain matrix formalism. More...
class	GainMatrixUpdater
	Update step of Kalman Filter using gain matrix formalism. More...
struct	KalmanFitterOptions
	Options struct how the Fitter is called. More...
struct	KalmanFitterResult
class	KalmanFitter
	Kalman fitter implementation of Acts as a plugin. More...
class	AnnealingUtility
	Implements a deterministic thermodynamic annealing scheme Ref. (1): CERN-THESIS-2010-027. More...
class	BinnedArray
class	BinnedArrayXD
class	BinningData
class	BinUtility
class	AxisAlignedBoundingBox
class	FiniteStateMachine
class	Frustum
class	IAxis
struct	Intersection
class	ObjectIntersection
	class extensions to return also the object and a representation More...
struct	SameSurfaceIntersection
class	Logger
	class for printing debug output More...
class	LoggerWrapper
	Class that contains (but doesn't own) a logger instance. Is callable so can be used with the logging macros. More...
class	MultiIndex
class	Ray
class	Result
class	Result< void, E >
class	AssertionFailureException
	Exception type for assertion failures This class captures the information available to the throw_assert macro. 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. More...
class	IterativeVertexFinder
	Implements an iterative vertex finder. More...
class	LinearizedTrack
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 visulation configuration in order to harmonize visualization interfaces. More...
class	MaterialWiper
class	Seedfinder< external_spacepoint_t, Acts::Cuda >
class	CpuMatrix
class	CpuScalar
class	CpuVector
class	ActsExtension
	Extension of the DD4hep DetElement needed for translation into the Acts tracking geometry. More...
class	DD4hepDetectorElement
	DetectorElement class implementation for DD4hep geometry. More...
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...
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
struct	DoubleHitSpacePointConfig
	Configuration of the class to steer its behaviour. More...
class	SpacePointBuilder< SpacePoint< Cluster > >
class	PlanarModuleCluster
class	PlanarModuleStepper
class	Segmentation
	Segmentation Base class. More...
struct	SpacePoint
	Structure for easier bookkeeping of space points. More...
struct	SpacePointBuilder
class	IdentifiedDetectorElement
	The identified detector element. More...
class	GeometryHierarchyMapJsonConverter
class	JsonGeometryConverter
	read the material from Json More...
class	JsonMaterialDecorator
	Material decorator from Json format. More...
class	ITGeoIdentifierProvider
	ITGeoIdentierProvider. More...
class	TGeoDetectorElement
class	TGeoLayerBuilder
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	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
template<typename source_link_t >
using	FittableMeasurement = typename fittable_measurement_helper< source_link_t >::type
	Measurement variant types.
template<typename source_link_t >
using	FittableVolumeMeasurement = typename fittable_volume_measurement_helper< source_link_t >::type
using	TrackStateType = std::bitset< TrackStateFlag::NumTrackStateFlags >
using	NeutralBoundTrackParameters = SingleBoundTrackParameters< Neutral >
using	NeutralCurvilinearTrackParameters = SingleCurvilinearTrackParameters< Neutral >
using	NeutralFreeTrackParameters = SingleFreeTrackParameters< Neutral >
using	FullBoundParameterSet = typename detail::full_parset< BoundIndices >::type
using	FullFreeParameterSet = typename detail::full_parset< FreeIndices >::type
using	BoundTrackParameters = SingleBoundTrackParameters< SinglyCharged >
using	CurvilinearTrackParameters = SingleCurvilinearTrackParameters< SinglyCharged >
using	FreeTrackParameters = SingleFreeTrackParameters< SinglyCharged >
using	BoundarySurfacePtr = std::shared_ptr< const BoundarySurfaceT< AbstractVolume >>
using	VolumeBoundsPtr = std::shared_ptr< const VolumeBounds >
using	Range = std::pair< double, double >
using	GeometryContext = std::any
	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< Vector3D >
using	V3Matrix = std::vector< V3Vector >
using	TrackingVolumeBoundaryPtr = std::shared_ptr< const BoundarySurfaceT< TrackingVolume >>
using	TrackingVolumeBoundaries = std::vector< TrackingVolumeBoundaryPtr >
using	LayerIntersection = ObjectIntersection< Layer, Surface >
using	BoundarySurface = BoundarySurfaceT< TrackingVolume >
using	BoundaryIntersection = ObjectIntersection< BoundarySurface, Surface >
using	TrackingVolumeOrderPosition = std::pair< TrackingVolumePtr, Vector3D >
using	SurfacePtr = std::shared_ptr< const Surface >
using	OrientedSurface = std::pair< SurfacePtr, NavigationDirection >
using	OrientedSurfaces = std::vector< OrientedSurface >
using	MagneticFieldContext = std::any
	This is the central definition of the Acts payload object regarding magnetic field status.
using	RecordedMaterialVolumePoint = std::vector< std::pair< Acts::MaterialSlab, std::vector< Acts::Vector3D >>>
	list of point used in the mapping of a volume
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	MaterialSlabVector = std::vector< MaterialSlab >
using	MaterialSlabMatrix = std::vector< MaterialSlabVector >
using	RecordedMaterial = MaterialInteractor::Result
	Using some short hands for Recorded Material.
using	RecordedMaterialTrack = std::pair< std::pair< Acts::Vector3D, Acts::Vector3D >, RecordedMaterial >
template<typename external_spacepoint_t >
using	SpacePointGrid = detail::Grid< std::vector< std::unique_ptr< const InternalSpacePoint< external_spacepoint_t >>>, detail::Axis< detail::AxisType::Equidistant, detail::AxisBoundaryType::Closed >, detail::Axis< detail::AxisType::Equidistant, detail::AxisBoundaryType::Bound >>
using	AlignmentScalar = double
	Underlying fundamental scalar type for alignment parameters.
using	AlignmentVector = ActsVector< AlignmentScalar, eAlignmentSize >
using	AlignmentRowVector = ActsRowVector< AlignmentScalar, eAlignmentSize >
using	AlingmentMatrix = ActsMatrix< AlignmentScalar, eAlignmentSize, eAlignmentSize >
using	AlignmentToLocalCartesianMatrix = ActsMatrix< AlignmentScalar, 3, eAlignmentSize >
using	AlignmentToBoundMatrix = ActsMatrix< BoundScalar, eBoundSize, eAlignmentSize >
using	CalibrationContext = std::any
	This is the central definition of the Acts payload object regarding detector calbiration.
template<typename T , unsigned int rows, unsigned int cols>
using	ActsMatrix = Eigen::Matrix< T, rows, cols >
template<unsigned int rows, unsigned int cols>
using	ActsMatrixD = ActsMatrix< double, rows, cols >
template<unsigned int rows, unsigned int cols>
using	ActsMatrixF = ActsMatrix< float, rows, cols >
template<typename T , unsigned int rows>
using	ActsSymMatrix = Eigen::Matrix< T, rows, rows >
template<unsigned int rows>
using	ActsSymMatrixD = ActsSymMatrix< double, rows >
template<unsigned int rows>
using	ActsSymMatrixF = ActsSymMatrix< float, rows >
template<typename T , unsigned int rows>
using	ActsVector = Eigen::Matrix< T, rows, 1 >
template<unsigned int rows>
using	ActsVectorD = ActsVector< double, rows >
template<unsigned int rows>
using	ActsVectorF = ActsVector< float, rows >
template<typename T , unsigned int cols>
using	ActsRowVector = Eigen::Matrix< T, 1, cols >
template<unsigned int cols>
using	ActsRowVectorD = ActsRowVector< double, cols >
template<unsigned int cols>
using	ActsRowVectorF = ActsRowVector< float, cols >
template<typename T >
using	ActsMatrixX = Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >
using	ActsMatrixXd = ActsMatrixX< double >
using	ActsMatrixXf = ActsMatrixX< float >
template<typename T >
using	ActsVectorX = Eigen::Matrix< T, Eigen::Dynamic, 1 >
using	ActsVectorXd = ActsVectorX< double >
using	ActsVectorXf = ActsVectorX< float >
template<typename T >
using	ActsRowVectorX = Eigen::Matrix< T, 1, Eigen::Dynamic >
using	ActsRowVectorXd = ActsRowVectorX< double >
using	ActsRowVectorXf = ActsRowVectorX< float >
using	Vector2F = ActsVector< float, 2 >
using	Vector3F = ActsVector< float, 3 >
using	Vector4F = ActsVector< float, 4 >
using	Vector2D = ActsVector< double, 2 >
using	Vector3D = ActsVector< double, 3 >
using	Vector4D = ActsVector< double, 4 >
using	SymMatrix2F = ActsSymMatrix< float, 2 >
using	SymMatrix3F = ActsSymMatrix< float, 3 >
using	SymMatrix4F = ActsSymMatrix< float, 4 >
using	SymMatrix2D = ActsSymMatrix< double, 2 >
using	SymMatrix3D = ActsSymMatrix< double, 3 >
using	SymMatrix4D = ActsSymMatrix< double, 4 >
using	Translation2F = Eigen::Translation< float, 2 >
using	Translation3F = Eigen::Translation< float, 3 >
using	Translation4F = Eigen::Translation< float, 4 >
using	Translation2D = Eigen::Translation< double, 2 >
using	Translation3D = Eigen::Translation< double, 3 >
using	Translation4D = Eigen::Translation< double, 4 >
using	RotationMatrix2F = Eigen::Matrix< float, 2, 2 >
using	RotationMatrix3F = Eigen::Matrix< float, 3, 3 >
using	RotationMatrix4F = Eigen::Matrix< float, 4, 4 >
using	RotationMatrix2D = Eigen::Matrix< double, 2, 2 >
using	RotationMatrix3D = Eigen::Matrix< double, 3, 3 >
using	RotationMatrix4D = Eigen::Matrix< double, 4, 4 >
using	Rotation2F = Eigen::Rotation2D< float >
using	Rotation3F = Eigen::Quaternion< float >
using	AngleAxis3F = Eigen::AngleAxis< float >
using	Rotation2D = Eigen::Rotation2D< double >
using	Rotation3D = Eigen::Quaternion< double >
using	AngleAxis3D = Eigen::AngleAxis< double >
using	Transform2F = Eigen::Transform< float, 2, Eigen::AffineCompact >
using	Transform3F = Eigen::Transform< float, 3, Eigen::Affine >
using	Transform4F = Eigen::Transform< float, 4, Eigen::AffineCompact >
using	Transform2D = Eigen::Transform< double, 2, Eigen::AffineCompact >
using	Transform3D = Eigen::Transform< double, 3, Eigen::Affine >
using	Transform4D = Eigen::Transform< double, 4, Eigen::AffineCompact >
using	Intersection2D = Intersection< 2 >
using	Intersection3D = Intersection< 3 >
using	BoundScalar = double
	Underlying fundamental scalar type for bound track parameters.
using	FreeScalar = double
	Underlying fundamental scalar type for free track parameters.
using	BoundVector = ActsVector< BoundScalar, eBoundSize >
using	BoundRowVector = ActsRowVector< BoundScalar, eBoundSize >
using	BoundMatrix = ActsMatrix< BoundScalar, eBoundSize, eBoundSize >
using	BoundSymMatrix = ActsSymMatrix< BoundScalar, eBoundSize >
using	LocalCartesianToBoundLocalMatrix = ActsMatrix< BoundScalar, 2, 3 >
using	FreeVector = ActsVector< FreeScalar, eFreeSize >
using	FreeRowVector = ActsRowVector< FreeScalar, eFreeSize >
using	FreeMatrix = ActsMatrix< FreeScalar, eFreeSize, eFreeSize >
using	FreeSymMatrix = ActsSymMatrix< FreeScalar, eFreeSize >
using	FreeToBoundMatrix = ActsMatrix< BoundScalar, eBoundSize, eFreeSize >
using	BoundToFreeMatrix = ActsMatrix< FreeScalar, eFreeSize, eBoundSize >
using	Ray3F = Ray< float, 3 >
using	Ray3D = Ray< double, 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	SurfacePtrVector = std::vector< SurfacePtr >
template<BoundIndices... params>
using	Measurement_t = Measurement< Identifier, BoundIndices, params...>
using	IdentifiedPolyhedron = std::tuple< std::string, bool, Polyhedron >

Enumerations
enum	TrackStateFlag {   MeasurementFlag = 0, ParameterFlag = 1, OutlierFlag = 2, HoleFlag = 3,   MaterialFlag = 4, NumTrackStateFlags = 5 }
enum	TrackStatePropMask : uint8_t
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	EigenStepperError
enum	PropagatorError
enum	SurfaceError
enum	CombinatorialKalmanFilterError
enum	KalmanFitterError
enum	AlignmentIndices : unsigned int {   eAlignmentCenter0 = 0u, eAlignmentCenter1 = eAlignmentCenter0 + 1u, eAlignmentCenter2 = eAlignmentCenter0 + 2u, eAlignmentRotation0 = 3u,   eAlignmentRotation1 = eAlignmentRotation0 + 1u, eAlignmentRotation2 = eAlignmentRotation0 + 2u, eAlignmentSize }
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	NavigationDirection : int { backward = -1, forward = 1 }
enum	MaterialUpdateStage : int { preUpdate = -1, fullUpdate = 0, postUpdate = 1 }
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	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	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 }
	Symbolic values for commonly used PDG particle numbers. More...
enum	VertexingError

Functions
std::ostream &	operator<< (std::ostream &os, const MinimalSourceLink &sl)
template<typename L , typename A , typename B >
auto	visit_measurement (A &&param, B &&cov, size_t dim, L &&lambda)
constexpr TrackStatePropMask	operator| (TrackStatePropMask lhs, TrackStatePropMask rhs)
constexpr TrackStatePropMask	operator& (TrackStatePropMask lhs, TrackStatePropMask rhs)
constexpr TrackStatePropMask	operator^ (TrackStatePropMask lhs, TrackStatePropMask rhs)
constexpr TrackStatePropMask	operator~ (TrackStatePropMask op)
constexpr TrackStatePropMask &	operator|= (TrackStatePropMask &lhs, TrackStatePropMask rhs)
constexpr TrackStatePropMask &	operator&= (TrackStatePropMask &lhs, TrackStatePropMask rhs)
constexpr TrackStatePropMask &	operator^= (TrackStatePropMask &lhs, TrackStatePropMask rhs)
std::ostream &	operator<< (std::ostream &os, BoundarySurfaceFace &face)
std::ostream &	operator<< (std::ostream &sl, const Extent &ext)
	Overload of << operator for std::ostream for debug output.
std::ostream &	operator<< (std::ostream &os, GeometryIdentifier id)
static const Vector3D	s_xAxis (1, 0, 0)
	global x Axis;
static const Vector3D	s_yAxis (0, 1, 0)
	global y Axis;
static const Vector3D	s_zAxis (0, 0, 1)
	global z Axis;
static const Vector2D	s_origin2D (0., 0.)
static const Vector3D	s_origin (0, 0, 0)
	origin position
static const RotationMatrix3D	s_idRotationZinverse (detail::_helper)
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::InterpolatedBFieldMapper < Acts::detail::Grid < Acts::Vector2D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	fieldMapperRZ (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::Vector2D > bField, double lengthUnit=UnitConstants::mm, double BFieldUnit=UnitConstants::T, bool firstQuadrant=false)
Acts::InterpolatedBFieldMapper < Acts::detail::Grid < Acts::Vector3D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	fieldMapperXYZ (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::Vector3D > bField, double lengthUnit=UnitConstants::mm, double BFieldUnit=UnitConstants::T, bool firstOctant=false)
Acts::InterpolatedBFieldMapper < Acts::detail::Grid < Acts::Vector2D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > >	solenoidFieldMapper (std::pair< double, double > rlim, std::pair< double, double > zlim, std::pair< size_t, size_t > nbins, const SolenoidBField &field)
float	computeEnergyLossBethe (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	deriveEnergyLossBetheQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossLandau (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	deriveEnergyLossLandauQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossLandauSigma (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossLandauSigmaQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossRadiative (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	deriveEnergyLossRadiativeQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossMean (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	deriveEnergyLossMeanQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeEnergyLossMode (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	deriveEnergyLossModeQOverP (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
float	computeMultipleScatteringTheta0 (const MaterialSlab &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
std::ostream &	operator<< (std::ostream &os, const Material &material)
Grid2D	createGrid (std::array< double, 3 > gridAxis1, std::array< double, 3 > 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 (std::array< double, 3 > gridAxis1, std::array< double, 3 > gridAxis2, std::array< double, 3 > 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::Vector3D)>	globalToLocalFromBin (Acts::BinningValue &type)
	return a function that return the coordinate corresponding to type of bin
Grid2D	createGrid2D (const BinUtility &bins, std::function< Acts::Vector2D(Acts::Vector3D)> &transfoGlobalToLocal)
	Create a 2DGrid using a BinUtility. Also determine the coresponding global to local transform and grid mapping function.
Grid3D	createGrid3D (const BinUtility &bins, std::function< Acts::Vector3D(Acts::Vector3D)> &transfoGlobalToLocal)
	Create a 3DGrid using a BinUtility. Also determine the coresponding global to local transform and grid mapping function.
MaterialGrid2D	mapMaterialPoints (Grid2D &grid, const Acts::RecordedMaterialVolumePoint &mPoints, std::function< Acts::Vector2D(Acts::Vector3D)> &transfoGlobalToLocal)
	Concatenate a set of material at arbitrary space points on a set of grid points and produces a grid containing the averaged material values.
MaterialGrid3D	mapMaterialPoints (Grid3D &grid, const Acts::RecordedMaterialVolumePoint &mPoints, std::function< Acts::Vector3D(Acts::Vector3D)> &transfoGlobalToLocal)
	Concatenate a set of material at arbitrary space points on a set of grid points and produces a grid containing the averaged material values.
MaterialMapper< detail::Grid < ActsVectorF < 5 >, 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, std::vector< Material > material, double lengthUnit=UnitConstants::mm)
MaterialMapper< detail::Grid < ActsVectorF < 5 >, 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, std::vector< Material > material, double lengthUnit=UnitConstants::mm)
std::ostream &	operator<< (std::ostream &os, const MaterialSlab &materialSlab)
const detail::EigenStepperErrorCategory &	EigenStepperErrorCategory ()
std::error_code	make_error_code (Acts::EigenStepperError e)
const detail::PropagatorErrorCategory &	PropagatorErrorCategory ()
std::error_code	make_error_code (Acts::PropagatorError e)
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)
const detail::SurfaceErrorCategory &	SurfaceErrorCategory ()
std::error_code	make_error_code (Acts::SurfaceError e)
const detail::CombinatorialKalmanFilterErrorCategory &	CombinatorialKalmanFilterErrorCategory ()
std::error_code	make_error_code (Acts::CombinatorialKalmanFilterError e)
const detail::KalmanFitterErrorCategory &	KalmanFitterErrorCategory ()
std::error_code	make_error_code (Acts::KalmanFitterError e)
BinUtility	adjustBinUtility (const BinUtility &bu, const RadialBounds &rBounds, const Transform3D &transform)
	adjust the BinUtility bu to the dimensions of radial bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CylinderBounds &cBounds, const Transform3D &transform)
	adjust the BinUtility bu to the dimensions of cylinder bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const Surface &surface)
	adjust the BinUtility bu to a surface
BinUtility	adjustBinUtility (const BinUtility &bu, const CylinderVolumeBounds &cBounds, const Transform3D &transform)
	adjust the BinUtility bu to the dimensions of cylinder volume bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CutoutCylinderVolumeBounds &cBounds, const Transform3D &transform)
	adjust the BinUtility bu to the dimensions of cutout cylinder volume bounds
BinUtility	adjustBinUtility (const BinUtility &bu, const CuboidVolumeBounds &cBounds, const Transform3D &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
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)
std::string	toString (const ActsMatrixXd &matrix, int precision=4, const std::string &offset="")
std::string	toString (const Acts::Translation3D &translation, int precision=4)
std::string	toString (const Acts::Transform3D &transform, int precision=4, const std::string &offset="")
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<template< size_t > class Callable, size_t N, size_t NMAX, typename... Args>
decltype(Callable< N >::invoke(std::declval < Args >()...))	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<typename MatrixType >
MatrixType	bitsetToMatrix (const std::bitset< MatrixType::RowsAtCompileTime *MatrixType::ColsAtCompileTime > bs)
template<typename Derived >
auto	matrixToBitset (const Eigen::PlainObjectBase< Derived > &m)
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::unique_ptr< const Logger >	getDefaultLogger (const std::string &name, const Logging::Level &lvl, std::ostream *log_stream=&std::cout)
	get default debug output logger
LoggerWrapper	getDummyLogger ()
constexpr PdgParticle	makeAbsolutePdgParticle (PdgParticle pdg)
	Convert an anti-particle to its particle and leave particles as-is.
template<typename T , size_t D>
std::ostream &	operator<< (std::ostream &os, const Ray< T, D > &ray)
template<typename T >
ActsVector< T, 3 >	makeDirectionUnitFromPhiEta (T phi, T eta)
template<typename T >
ActsVector< T, 3 >	makeDirectionUnitFromPhiTheta (T phi, T theta)
template<typename InputVector >
auto	makeCurvilinearUnitU (const Eigen::MatrixBase< InputVector > &direction)
template<typename InputVector >
auto	makeCurvilinearUnitVectors (const Eigen::MatrixBase< InputVector > &direction)
const detail::VertexingErrorCategory &	VertexingErrorCategory ()
std::error_code	make_error_code (Acts::VertexingError e)
std::ostream &	operator<< (std::ostream &os, const IVisualization3D &hlp)
std::ostream &	operator<< (std::ostream &os, PdgParticle pdg)
void	sortDetElementsByID (std::vector< dd4hep::DetElement > &det)
std::unique_ptr< const TrackingGeometry >	convertDD4hepDetector (dd4hep::DetElement worldDetElement, Logging::Level loggingLevel=Logging::Level::INFO, 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)
	Global method which creates the TrackingGeometry from DD4hep input.
std::shared_ptr< const CylinderVolumeBuilder >	volumeBuilder_dd4hep (dd4hep::DetElement subDetector, Logging::Level loggingLevel=Logging::Level::INFO, 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 (Logging::Level loggingLevel=Logging::Level::INFO)
void	collectSubDetectors_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &subdetectors)
void	collectCompounds_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &compounds)
void	collectLayers_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &layers)
void	collectVolumes_dd4hep (dd4hep::DetElement &detElement, std::vector< dd4hep::DetElement > &volumes)
void	addCylinderLayerProtoMaterial (dd4hep::DetElement detElement, Layer &cylinderLayer, Logging::Level loggingLevel=Logging::Level::INFO)
void	addDiscLayerProtoMaterial (dd4hep::DetElement detElement, Layer &discLayer, Logging::Level loggingLevel=Logging::Level::INFO)
void	addLayerProtoMaterial (const ActsExtension &actsExtension, Layer &layer, const std::vector< std::pair< const std::string, Acts::BinningOption > > &binning)
std::shared_ptr < Acts::ProtoSurfaceMaterial >	createProtoMaterial (const ActsExtension &actsExtension, const std::string &valueTag, const std::vector< std::pair< const std::string, Acts::BinningOption > > &binning)
void	xmlToProtoSurfaceMaterial (const xml_comp_t &x_material, ActsExtension &actsExtension, const std::string &baseTag)
template<typename cell_t >
std::vector< std::vector < cell_t > >	createClusters (std::unordered_map< size_t, std::pair< cell_t, bool >> &cellMap, size_t nBins0, bool commonCorner=true, double energyCut=0.)
	create clusters This function recieves digitization cells and bundles the neighbouring to create clusters later and does cell merging. Furthermore an energy cut (excluding cells which fall below threshold) can be applied. The function is templated on the digitization cell type to allow users to use their own implementation of Acts::DigitizationCell.
template<typename cell_t >
void	fillCluster (std::vector< std::vector< cell_t >> &mergedCells, std::unordered_map< size_t, std::pair< cell_t, bool >> &cellMap, size_t index, size_t nBins0, bool commonCorner=true, double energyCut=0.)
	fillCluster This function is a helper function internally used by Acts::createClusters. It does connected component labelling using a hash map in order to find out which cells are neighbours. This function is called recursively by all neighbours of the current cell. The function is templated on the digitization cell type to allow users to use their own implementation inheriting from Acts::DigitizationCell.
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

Variables
template<typename T >
constexpr bool	SourceLinkConcept
static const Transform3D	s_idTransform
	idendity transformation
static const Rotation3D	s_idRotation
	idendity rotation
static const Transform3D	s_planeXY = Transform3D::Identity()
static const Transform3D	s_planeYZ
static const Transform3D	s_planeZX
template<typename stepper , typename state = typename stepper::State>
constexpr bool	StepperConcept
template<typename stepper >
constexpr bool	StepperStateConcept
constexpr int	PolygonDynamic = -1
	Tag to trigger specialization of a dynamic polygon.
static const InfiniteBounds	s_noBounds {}
static const std::vector < std::string >	binningValueNames
	screen output option
static constexpr double	s_epsilon = 3 * std::numeric_limits<double>::epsilon()
	Tolerance for bein numerical equal for geometry building.
static constexpr double	s_onSurfaceTolerance = 1e-4
static constexpr double	s_curvilinearProjTolerance = 0.999995
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})
GeometryContext	tgContext = GeometryContext()
std::shared_ptr< const TrackingGeometry >	tGeometry = trackingGeometry()
Transform3D	aTransform

Detailed Description

Set the Geometry Context PLUGIN.

Ats namespace.

Set the Calibration Context PLUGIN.

Set the Mangetic Field Context PLUGIN.

Define statics for Geometry in Tracking

Convenience functions to ease creation of and Acts::InterpolatedBFieldMap and to avoid code duplication. Currently implemented for the two most common formats: rz and xyz.

Convenience functions to ease creation of and Acts::InterpolatedMaterialMap and to avoid code duplication. Currently implemented for the two most common formats: rz and xyz.

Note

The used variables in this file are:

Template Parameters

N	Size of the tuple obs_tuple
propagator_state_t	Type of the state of the propagation
stepper_t	Type of the stepper
T	Types of the extensions

Parameters

obs_tuple	Extendable tuple of extensions
state	State of the propagation
stepper	Stepper of the propagation
bids	List that collects bids about validity of an extension for an upcoming step
validExtensions	List of valid extensions that will be used
knew	k_1 - k_4 that is about to be evaluated in the upcoming call
bField	B-field at a certain point
i	Defines the calculation of knew=k_{i+1}
h	Distance to the starting point k_1
kprev	k_i that is used for the evaluation for knew
D	Transport matrix of the jacobian

Typedef Documentation

template<typename T , unsigned int rows, unsigned int cols>

using Acts::ActsMatrix = typedef Eigen::Matrix<T, rows, cols>

Definition at line 61 of file Definitions.hpp.

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

template<unsigned int rows, unsigned int cols>

using Acts::ActsMatrixD = typedef ActsMatrix<double, rows, cols>

Definition at line 64 of file Definitions.hpp.

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

template<unsigned int rows, unsigned int cols>

using Acts::ActsMatrixF = typedef ActsMatrix<float, rows, cols>

Definition at line 67 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 67 of file Definitions.hpp

template<typename T >

using Acts::ActsMatrixX = typedef Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

Definition at line 97 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 97 of file Definitions.hpp

using Acts::ActsMatrixXd = typedef ActsMatrixX<double>

Definition at line 99 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 99 of file Definitions.hpp

using Acts::ActsMatrixXf = typedef ActsMatrixX<float>

Definition at line 100 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 100 of file Definitions.hpp

template<typename T , unsigned int cols>

using Acts::ActsRowVector = typedef Eigen::Matrix<T, 1, cols>

Definition at line 88 of file Definitions.hpp.

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

template<unsigned int cols>

using Acts::ActsRowVectorD = typedef ActsRowVector<double, cols>

Definition at line 91 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 91 of file Definitions.hpp

template<unsigned int cols>

using Acts::ActsRowVectorF = typedef ActsRowVector<float, cols>

Definition at line 94 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 94 of file Definitions.hpp

template<typename T >

using Acts::ActsRowVectorX = typedef Eigen::Matrix<T, 1, Eigen::Dynamic>

Definition at line 109 of file Definitions.hpp.

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

using Acts::ActsRowVectorXd = typedef ActsRowVectorX<double>

Definition at line 111 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 111 of file Definitions.hpp

using Acts::ActsRowVectorXf = typedef ActsRowVectorX<float>

Definition at line 112 of file Definitions.hpp.

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

template<typename T , unsigned int rows>

using Acts::ActsSymMatrix = typedef Eigen::Matrix<T, rows, rows>

Definition at line 70 of file Definitions.hpp.

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

template<unsigned int rows>

using Acts::ActsSymMatrixD = typedef ActsSymMatrix<double, rows>

Definition at line 73 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 73 of file Definitions.hpp

template<unsigned int rows>

using Acts::ActsSymMatrixF = typedef ActsSymMatrix<float, rows>

Definition at line 76 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 76 of file Definitions.hpp

template<typename T , unsigned int rows>

using Acts::ActsVector = typedef Eigen::Matrix<T, rows, 1>

Definition at line 79 of file Definitions.hpp.

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

template<unsigned int rows>

using Acts::ActsVectorD = typedef ActsVector<double, rows>

Definition at line 82 of file Definitions.hpp.

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

template<unsigned int rows>

using Acts::ActsVectorF = typedef ActsVector<float, rows>

Definition at line 85 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 85 of file Definitions.hpp

template<typename T >

using Acts::ActsVectorX = typedef Eigen::Matrix<T, Eigen::Dynamic, 1>

Definition at line 103 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 103 of file Definitions.hpp

using Acts::ActsVectorXd = typedef ActsVectorX<double>

Definition at line 105 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 105 of file Definitions.hpp

using Acts::ActsVectorXf = typedef ActsVectorX<float>

Definition at line 106 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 106 of file Definitions.hpp

using Acts::AlignmentRowVector = typedef ActsRowVector<AlignmentScalar, eAlignmentSize>

Definition at line 39 of file AlignmentDefinitions.hpp.

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

using Acts::AlignmentScalar = typedef double

Underlying fundamental scalar type for alignment parameters.

Definition at line 35 of file AlignmentDefinitions.hpp.

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

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

Definition at line 45 of file AlignmentDefinitions.hpp.

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

using Acts::AlignmentToLocalCartesianMatrix = typedef ActsMatrix<AlignmentScalar, 3, eAlignmentSize>

Definition at line 43 of file AlignmentDefinitions.hpp.

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

using Acts::AlignmentVector = typedef ActsVector<AlignmentScalar, eAlignmentSize>

Definition at line 38 of file AlignmentDefinitions.hpp.

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

using Acts::AlingmentMatrix = typedef ActsMatrix<AlignmentScalar, eAlignmentSize, eAlignmentSize>

Definition at line 41 of file AlignmentDefinitions.hpp.

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

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

Definition at line 58 of file TrackingVolume.hpp.

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

using Acts::BoundarySurface = typedef BoundarySurfaceT<TrackingVolume>

Definition at line 57 of file TrackingVolume.hpp.

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

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

Definition at line 20 of file AbstractVolume.hpp.

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

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

Definition at line 131 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 131 of file ParameterDefinitions.hpp

using Acts::BoundRowVector = typedef ActsRowVector<BoundScalar, eBoundSize>

Definition at line 130 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 130 of file ParameterDefinitions.hpp

using Acts::BoundScalar = typedef double

Underlying fundamental scalar type for bound track parameters.

Definition at line 59 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 59 of file ParameterDefinitions.hpp

using Acts::BoundSymMatrix = typedef ActsSymMatrix<BoundScalar, eBoundSize>

Definition at line 132 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 132 of file ParameterDefinitions.hpp

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

Definition at line 157 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 157 of file ParameterDefinitions.hpp

using Acts::BoundTrackParameters = typedef SingleBoundTrackParameters<SinglyCharged>

Definition at line 22 of file TrackParameters.hpp.

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

using Acts::BoundVector = typedef ActsVector<BoundScalar, eBoundSize>

Definition at line 129 of file ParameterDefinitions.hpp.

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

using Acts::CalibrationContext = typedef std::any

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

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 18 of file ViewConfig.hpp.

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

using Acts::CurvilinearTrackParameters = typedef SingleCurvilinearTrackParameters<SinglyCharged>

Definition at line 24 of file TrackParameters.hpp.

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

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

Definition at line 26 of file IMaterialWriter.hpp.

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

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

Definition at line 26 of file MaterialGridHelper.hpp.

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

template<typename source_link_t >

using Acts::FittableMeasurement = typedef typename fittable_measurement_helper<source_link_t>::type

Measurement variant types.

Definition at line 361 of file Measurement.hpp.

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

template<typename source_link_t >

using Acts::FittableVolumeMeasurement = typedef typename fittable_volume_measurement_helper<source_link_t>::type

Definition at line 365 of file Measurement.hpp.

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

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

Definition at line 140 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 140 of file ParameterDefinitions.hpp

using Acts::FreeRowVector = typedef ActsRowVector<FreeScalar, eFreeSize>

Definition at line 139 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 139 of file ParameterDefinitions.hpp

using Acts::FreeScalar = typedef double

Underlying fundamental scalar type for free track parameters.

Definition at line 88 of file ParameterDefinitions.hpp.

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

using Acts::FreeSymMatrix = typedef ActsSymMatrix<FreeScalar, eFreeSize>

Definition at line 141 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 141 of file ParameterDefinitions.hpp

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

Definition at line 149 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 149 of file ParameterDefinitions.hpp

using Acts::FreeTrackParameters = typedef SingleFreeTrackParameters<SinglyCharged>

Definition at line 25 of file TrackParameters.hpp.

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

using Acts::FreeVector = typedef ActsVector<FreeScalar, eFreeSize>

Definition at line 138 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 138 of file ParameterDefinitions.hpp

using Acts::FullBoundParameterSet = typedef typename detail::full_parset<BoundIndices>::type

Definition at line 30 of file ParameterSet.hpp.

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

using Acts::FullFreeParameterSet = typedef typename detail::full_parset<FreeIndices>::type

Definition at line 31 of file ParameterSet.hpp.

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

using Acts::GeometryContext = typedef std::any

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 28 of file MaterialGridHelper.hpp.

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

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

Definition at line 30 of file MaterialGridHelper.hpp.

View newest version in sPHENIX GitHub at line 30 of file MaterialGridHelper.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 86 of file Intersection.hpp.

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

using Acts::Intersection3D = typedef Intersection<3>

Definition at line 88 of file Intersection.hpp.

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

typedef BinnedArray< LayerPtr > Acts::LayerArray

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

Layers are constructedd 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>

Definition at line 54 of file TrackingVolume.hpp.

View newest version in sPHENIX GitHub at line 54 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::LocalCartesianToBoundLocalMatrix = typedef ActsMatrix<BoundScalar, 2, 3>

Definition at line 134 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 134 of file ParameterDefinitions.hpp

using Acts::MagneticFieldContext = typedef std::any

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 32 of file MaterialGridHelper.hpp.

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

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

Definition at line 34 of file MaterialGridHelper.hpp.

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

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

Definition at line 87 of file MaterialSlab.hpp.

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

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

Definition at line 86 of file MaterialSlab.hpp.

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

template<BoundIndices... params>

using Acts::Measurement_t = typedef Measurement<Identifier, BoundIndices, params...>

Definition at line 29 of file PlanarModuleCluster.hpp.

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

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

Definition at line 41 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 41 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::NeutralBoundTrackParameters = typedef SingleBoundTrackParameters<Neutral>

Definition at line 22 of file NeutralTrackParameters.hpp.

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

using Acts::NeutralCurvilinearTrackParameters = typedef SingleCurvilinearTrackParameters<Neutral>

Definition at line 24 of file NeutralTrackParameters.hpp.

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

using Acts::NeutralFreeTrackParameters = typedef SingleFreeTrackParameters<Neutral>

Definition at line 25 of file NeutralTrackParameters.hpp.

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

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

Definition at line 42 of file Layer.hpp.

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

using Acts::OrientedSurface = typedef std::pair<SurfacePtr, NavigationDirection>

Definition at line 28 of file VolumeBounds.hpp.

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

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

Definition at line 29 of file VolumeBounds.hpp.

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

using Acts::Range = typedef std::pair<double, double>

Definition at line 21 of file Extent.hpp.

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

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

Definition at line 82 of file Ray.hpp.

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

using Acts::Ray3F = typedef Ray<float, 3>

Definition at line 81 of file Ray.hpp.

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

typedef MaterialInteractor::result_type Acts::RecordedMaterial

Using some short hands for Recorded Material.

Definition at line 234 of file MaterialInteractor.hpp.

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

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

And recorded material track

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

Definition at line 240 of file MaterialInteractor.hpp.

View newest version in sPHENIX GitHub at line 240 of file MaterialInteractor.hpp

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

list of point used in the mapping of a volume

Definition at line 24 of file MaterialGridHelper.hpp.

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

template<typename external_spacepoint_t >

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

Definition at line 46 of file SpacePointGrid.hpp.

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

typedef ObjectIntersection< Surface > Acts::SurfaceIntersection

Typedef of the surface intersection.

Definition at line 36 of file Layer.hpp.

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

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

Definition at line 28 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 21 of file IMaterialWriter.hpp.

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

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

Definition at line 31 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 27 of file VolumeBounds.hpp.

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

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

Definition at line 20 of file DigitizationModule.hpp.

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

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

Definition at line 30 of file SurfaceArrayCreator.hpp.

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

typedef BinnedArray< TrackingVolumePtr > Acts::TrackingVolumeArray

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

Definition at line 22 of file GlueVolumesDescriptor.hpp.

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

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

Definition at line 44 of file TrackingVolume.hpp.

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

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

Definition at line 43 of file TrackingVolume.hpp.

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

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

Definition at line 24 of file TrackingVolumeArrayCreator.hpp.

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

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

A std::shared_ptr to a tracking volume.

Definition at line 21 of file GlueVolumesDescriptor.hpp.

View newest version in sPHENIX GitHub at line 21 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::TrackStateType = typedef std::bitset<TrackStateFlag::NumTrackStateFlags>

Definition at line 38 of file MultiTrajectory.hpp.

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

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

Definition at line 34 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 33 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 23 of file AbstractVolume.hpp.

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

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

Definition at line 24 of file IMaterialWriter.hpp.

View newest version in sPHENIX GitHub at line 24 of file IMaterialWriter.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 21 of file AlignmentDefinitions.hpp.

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

enum Acts::BinningOption

flag for open/closed bins

Enumerator:

open
closed

Definition at line 36 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 36 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 33 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 33 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 39 of file BinningType.hpp.

View newest version in sPHENIX GitHub at line 39 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 ment 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 cycular 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 ParameterDefinitions.hpp.

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

enum Acts::CombinatorialKalmanFilterError

Definition at line 17 of file CombinatorialKalmanFilterError.hpp.

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

enum Acts::EigenStepperError

Definition at line 17 of file EigenStepperError.hpp.

View newest version in sPHENIX GitHub at line 17 of file EigenStepperError.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 67 of file ParameterDefinitions.hpp.

View newest version in sPHENIX GitHub at line 67 of file ParameterDefinitions.hpp

enum Acts::KalmanFitterError

Definition at line 17 of file KalmanFitterError.hpp.

View newest version in sPHENIX GitHub at line 17 of file KalmanFitterError.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 48 of file Layer.hpp.

View newest version in sPHENIX GitHub at line 48 of file Layer.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

Enumerator:

preUpdate
fullUpdate
postUpdate

Definition at line 47 of file Definitions.hpp.

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

enum Acts::NavigationDirection : int

The navigation direciton is always with respect to a given momentum or direction

Enumerator:

backward
forward

Definition at line 41 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 41 of file Definitions.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 57 of file Definitions.hpp.

View newest version in sPHENIX GitHub at line 57 of file Definitions.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

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 17 of file PropagatorError.hpp.

View newest version in sPHENIX GitHub at line 17 of file PropagatorError.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
NumTrackStateFlags

Definition at line 29 of file MultiTrajectory.hpp.

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

enum Acts::TrackStatePropMask : 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 24 of file TrackStatePropMask.hpp.

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

enum Acts::VertexingError

Definition at line 17 of file VertexingError.hpp.

View newest version in sPHENIX GitHub at line 17 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 32 of file CylinderVolumeBuilder.hpp.

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

Function Documentation

void Acts::addCylinderLayerProtoMaterial	(	dd4hep::DetElement	detElement,
		Layer &	cylinderLayer,
		Logging::Level	loggingLevel = Logging::Level::INFO
	)

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
loggingLevel	is the output level for the conversion

Returns

a map of the identification string and a surface material

Definition at line 87 of file ConvertDD4hepMaterial.cpp.

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

References ACTS_LOCAL_LOGGER, ACTS_VERBOSE, addLayerProtoMaterial(), closed, getDefaultLogger(), 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,
		Logging::Level	loggingLevel = Logging::Level::INFO
	)

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
loggingLevel	is the output level for the conversion

Returns

a map of the identification string and a surface material

Definition at line 127 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 127 of file ConvertDD4hepMaterial.cpp

References ACTS_LOCAL_LOGGER, ACTS_VERBOSE, addLayerProtoMaterial(), closed, getDefaultLogger(), 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 ActsExtension &	actsExtension,
		Layer &	layer,
		const std::vector< std::pair< const std::string, Acts::BinningOption > > &	binning
	)

Helper method to be called for Cylinder and Disc Proto material

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

Parameters

aExtension	the ActsExtension for the binning parameters
layer	the Layer to assign the proto material
binning	the Binning prescription for the ActsExtension

Definition at line 53 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 53 of file ConvertDD4hepMaterial.cpp

References Acts::Layer::approachDescriptor(), Acts::Surface::assignSurfaceMaterial(), Acts::ApproachDescriptor::containedSurfaces(), createProtoMaterial(), Acts::ActsExtension::hasValue(), 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 Transform3D &	transform
	)

adjust the BinUtility bu to the dimensions of radial bounds

Parameters

bu	BinUtility at source
rBounds	the Radial bounds to adjust to

Returns

new updated BinUtiltiy

Definition at line 33 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 33 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(), max, Acts::Test::maxPhi, min, and Acts::Test::minPhi.

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 Transform3D &	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

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(), max, Acts::Test::maxPhi, min, and Acts::Test::minPhi.

Here is the call graph for this function:

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

adjust the BinUtility bu to the dimensions of cylinder bounds

Parameters

bu	BinUtility at source
cBounds	the Cylinder bounds to adjust to

Returns

new updated BinUtiltiy

Definition at line 81 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 81 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(), max, Acts::Test::maxPhi, min, and Acts::Test::minPhi.

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CutoutCylinderVolumeBounds &	cBounds,
		const Transform3D &	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

Returns

new updated BinUtiltiy

Definition at line 87 of file BinAdjustmentVolume.hpp.

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

References arbitrary, Acts::BinUtility::binningData(), binPhi, binR, binZ, Acts::CutoutCylinderVolumeBounds::eHalfLengthZ, Acts::CutoutCylinderVolumeBounds::eMaxR, Acts::CutoutCylinderVolumeBounds::eMinR, Acts::CutoutCylinderVolumeBounds::get(), M_PI, max, Acts::Test::maxPhi, min, and Acts::Test::minPhi.

Here is the call graph for this function:

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

adjust the BinUtility bu to a surface

Parameters

bu	BinUtility at source
Surface	to which the adjustment is being done

Returns

new updated BinUtiltiy

Definition at line 133 of file BinAdjustment.hpp.

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

References adjustBinUtility(), Acts::Surface::bounds(), Acts::Surface::Cylinder, Acts::Surface::Disc, Acts::Surface::transform(), and Acts::Surface::type().

Here is the call graph for this function:

BinUtility Acts::adjustBinUtility	(	const BinUtility &	bu,
		const CuboidVolumeBounds &	cBounds,
		const Transform3D &	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

Returns

new updated BinUtiltiy

Definition at line 141 of file BinAdjustmentVolume.hpp.

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

References arbitrary, Acts::BinUtility::binningData(), binX, binY, binZ, Acts::CuboidVolumeBounds::eHalfLengthX, Acts::CuboidVolumeBounds::eHalfLengthY, Acts::CuboidVolumeBounds::eHalfLengthZ, Acts::CuboidVolumeBounds::get(), max, and 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	to which the adjustment is being done

Returns

new updated BinUtiltiy

Definition at line 193 of file BinAdjustmentVolume.hpp.

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

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

Here is the call 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 378 of file Helpers.hpp.

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

References Acts::UnitConstants::m, and p.

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 518 of file ConvertDD4hepDetector.cpp.

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

References Acts::UnitConstants::e, and Acts::ActsExtension::hasType().

Referenced by volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Definition at line 562 of file ConvertDD4hepDetector.cpp.

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

References Acts::UnitConstants::e, and Acts::ActsExtension::hasType().

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
	)

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

Definition at line 538 of file ConvertDD4hepDetector.cpp.

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

References Acts::UnitConstants::e, and Acts::ActsExtension::hasType().

Referenced by convertDD4hepDetector().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::collectVolumes_dd4hep	(	dd4hep::DetElement &	detElement,
		std::vector< dd4hep::DetElement > &	volumes
	)

Method internally used by convertDD4hepDetector

Parameters

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

Definition at line 580 of file ConvertDD4hepDetector.cpp.

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

References Acts::UnitConstants::e, and Acts::ActsExtension::hasType().

Referenced by volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

const detail::CombinatorialKalmanFilterErrorCategory& Acts::CombinatorialKalmanFilterErrorCategory ( )

inline

Definition at line 59 of file CombinatorialKalmanFilterError.hpp.

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

References c.

float Acts::computeEnergyLossBethe	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

Compute the mean energy loss due to ionisation and excitation.

Parameters

slab	The traversed material and its properties
pdg	Particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
q	Particle charge, only the magnitude is considered

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 142 of file Interactions.cpp.

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

References ASSERT_INPUTS, eps, I, thickness, and Acts::UnitConstants::u.

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

Here is the caller graph for this function:

float Acts::computeEnergyLossLandau	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossBethe for parameters description

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 209 of file Interactions.cpp.

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

References ASSERT_INPUTS, eps, I, t, and thickness.

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

Here is the caller graph for this function:

float Acts::computeEnergyLossLandauSigma	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossBethe for parameters description

This is the sigma paramter 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 284 of file Interactions.cpp.

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

References ASSERT_INPUTS, and thickness.

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

Here is the caller graph for this function:

float Acts::computeEnergyLossLandauSigmaQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossBethe for parameters description

Definition at line 302 of file Interactions.cpp.

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

References ASSERT_INPUTS, and thickness.

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

Here is the caller graph for this function:

float Acts::computeEnergyLossMean	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

Compute the combined mean energy loss.

Parameters

slab	The traversed material and its properties
pdg	Particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
q	Particle charge, only the magnitude is considered

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 441 of file Interactions.cpp.

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

References computeEnergyLossBethe(), and computeEnergyLossRadiative().

Referenced by BOOST_DATA_TEST_CASE(), Acts::DenseEnvironmentExtension::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,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

Compute the combined most probably energy loss.

See Also

computeEnergyLossMean for parameters description.

Definition at line 453 of file Interactions.cpp.

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

References computeEnergyLossLandau(), and computeEnergyLossRadiative().

Referenced by BOOST_DATA_TEST_CASE(), and Acts::DenseEnvironmentExtension::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::computeEnergyLossRadiative	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

Parameters

slab	The traversed material and its properties
pdg	Particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
q	Particle charge, only the magnitude is considered

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 384 of file Interactions.cpp.

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

References ASSERT_INPUTS, eAntiMuon, eMuon, momentum, and x.

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

Here is the caller graph for this function:

float Acts::computeMultipleScatteringTheta0	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

Compute the core width of the projected planar scattering distribution.

Parameters

slab	The traversed material and its properties
pdg	Particle type PDG identifier
m	Particle mass
qOverP	Particle charge divided by absolute momentum
q	Particle charge, only the magnitude is considered

Definition at line 492 of file Interactions.cpp.

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

References kdfinder::abs(), ASSERT_INPUTS, eElectron, and ePositron.

Referenced by BOOST_DATA_TEST_CASE(), Acts::detail::PointwiseMaterialInteraction::covarianceContributions(), ActsFatras::detail::Highland::operator()(), ActsFatras::detail::GeneralMixture::operator()(), and ActsFatras::detail::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 89 of file TrackingVolumeCreation.hpp.

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

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

Here is the call 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 23 of file TrackingVolumeCreation.hpp.

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

References Acts::CylinderLayer::create(), Acts::TrackingVolume::create(), name, Acts::Test::surfaceHalfLengthZ, Acts::Test::surfaceRstagger, Acts::Test::volume, and Acts::Test::volumeEnvelope.

Here is the call graph for this function:

std::unique_ptr< const TrackingGeometry > Acts::convertDD4hepDetector	(	dd4hep::DetElement	worldDetElement,
		Logging::Level	loggingLevel = Logging::Level::INFO,
		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
	)

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]	loggingLevel	is the debug logging level of the conversion and 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 inbetween 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 hierachies need to be sorted ascending. The default is sorting by ID.
	matDetcroator	is the material decorator that loads material maps

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 hierachies 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 34 of file ConvertDD4hepDetector.cpp.

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

References ACTS_INFO, ACTS_LOCAL_LOGGER, collectSubDetectors_dd4hep(), cylinderVolumeHelper_dd4hep(), getDefaultLogger(), Acts::TrackingGeometryBuilder::Config::materialDecorator, Acts::TrackingGeometryBuilder::Config::trackingVolumeBuilders, Acts::TrackingGeometryBuilder::Config::trackingVolumeHelper, and volumeBuilder_dd4hep().

Referenced by ActsExamples::DD4hep::DD4hepGeometryService::buildTrackingGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename cell_t >

std::vector< std::vector< cell_t > > Acts::createClusters	(	std::unordered_map< size_t, std::pair< cell_t, bool >> &	cellMap,
		size_t	nBins0,
		bool	commonCorner = true,
		double	energyCut = 0.
	)

create clusters This function recieves digitization cells and bundles the neighbouring to create clusters later and does cell merging. Furthermore an energy cut (excluding cells which fall below threshold) can be applied. The function is templated on the digitization cell type to allow users to use their own implementation of Acts::DigitizationCell.

Template Parameters

Cell	the digitization cell

Parameters

[in]	cellMap	map of all cells per cell ID on module
[in]	nBins0	number of bins in direction 0
[in]	commonCorner	flag indicating if also cells sharing a common corner should be merged into one cluster
[in]	energyCut	possible energy cut to be applied

Returns

vector (the different clusters) of vector of digitization cells (the cells which belong to each cluster)

Definition at line 15 of file Clusterization.ipp.

View newest version in sPHENIX GitHub at line 15 of file Clusterization.ipp

References fillCluster().

Here is the call graph for this function:

Acts::Grid2D Acts::createGrid	(	std::array< double, 3 >	gridAxis1,
		std::array< double, 3 >	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 11 of file MaterialGridHelper.cpp.

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

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

Here is the caller graph for this function:

Acts::Grid3D Acts::createGrid	(	std::array< double, 3 >	gridAxis1,
		std::array< double, 3 >	gridAxis2,
		std::array< double, 3 >	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 38 of file MaterialGridHelper.cpp.

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

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

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

Parameters

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

Returns

the 3D grid

Definition at line 119 of file MaterialGridHelper.cpp.

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

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

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

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::Vector3D(Acts::Vector3D)> &	transfoGlobalToLocal
	)

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

Parameters

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

Returns

the 3D grid

Definition at line 163 of file MaterialGridHelper.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< Acts::ProtoSurfaceMaterial > Acts::createProtoMaterial	(	const ActsExtension &	actsExtension,
		const std::string &	valueTag,
		const std::vector< std::pair< const std::string, Acts::BinningOption > > &	binning
	)

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

Parameters

actsExtension	the ActExtension to be checked
valueTag	the xml tag for to ActsExtension to be parsed
firstBinning	string lookup for first bin
binning	the Binning prescription for the ActsExtension

Definition at line 25 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 25 of file ConvertDD4hepMaterial.cpp

References binningValueNames, charm_jet_strange_helicity::bins, closed, Acts::ActsExtension::getValue(), M_PI, max, and min.

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

(

Logging::Level

loggingLevel = Logging::Level::INFO

)

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

Definition at line 493 of file ConvertDD4hepDetector.cpp.

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

References getDefaultLogger(), 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:

float Acts::deriveEnergyLossBetheQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossBethe for parameters description

Definition at line 169 of file Interactions.cpp.

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

References ASSERT_INPUTS, eps, I, thickness, and Acts::UnitConstants::u.

Referenced by deriveEnergyLossMeanQOverP().

Here is the caller graph for this function:

float Acts::deriveEnergyLossLandauQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossBethe for parameters description

Definition at line 231 of file Interactions.cpp.

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

References ASSERT_INPUTS, eps, I, t, and thickness.

Referenced by deriveEnergyLossModeQOverP().

Here is the caller graph for this function:

float Acts::deriveEnergyLossMeanQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossMean for parameters description.

Definition at line 447 of file Interactions.cpp.

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

References deriveEnergyLossBetheQOverP(), and deriveEnergyLossRadiativeQOverP().

Referenced by Acts::DenseEnvironmentExtension::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossModeQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossMean for parameters description.

Definition at line 461 of file Interactions.cpp.

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

References deriveEnergyLossLandauQOverP(), and deriveEnergyLossRadiativeQOverP().

Referenced by Acts::DenseEnvironmentExtension::initializeEnergyLoss().

Here is the call graph for this function:

Here is the caller graph for this function:

float Acts::deriveEnergyLossRadiativeQOverP	(	const MaterialSlab &	slab,
		int	pdg,
		float	m,
		float	qOverP,
		float	q = UnitConstants::e
	)

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

See Also

computeEnergyLossRadiative for parameters description

Definition at line 409 of file Interactions.cpp.

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

References ASSERT_INPUTS, eAntiMuon, eMuon, momentum, and x.

Referenced by deriveEnergyLossMeanQOverP(), and deriveEnergyLossModeQOverP().

Here is the caller graph for this function:

const detail::EigenStepperErrorCategory& Acts::EigenStepperErrorCategory ( )

inline

Definition at line 47 of file EigenStepperError.hpp.

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

References c.

Acts::InterpolatedBFieldMapper< Acts::detail::Grid< Acts::Vector2D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::fieldMapperRZ	(	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::Vector2D >	bField,
		double	lengthUnit = UnitConstants::mm,
		double	BFieldUnit = UnitConstants::T,
		bool	firstQuadrant = false
	)

Method to setup the FieldMapper

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 and that the BFieldMap should be created symmetrically 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}.

Definition at line 24 of file BFieldMapUtils.cpp.

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

References kdfinder::abs(), min, n, Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), and pos().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), ActsExamples::BField::txt::fieldMapperRZ(), and ActsExamples::BField::root::fieldMapperRZ().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::InterpolatedBFieldMapper< Acts::detail::Grid< Acts::Vector3D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::fieldMapperXYZ	(	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::Vector3D >	bField,
		double	lengthUnit = UnitConstants::mm,
		double	BFieldUnit = UnitConstants::T,
		bool	firstOctant = false
	)

Method to setup the FieldMapper

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

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]

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 and that the BFieldMap should be created symmetrically 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}.

Definition at line 132 of file BFieldMapUtils.cpp.

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

References kdfinder::abs(), k, Acts::UnitConstants::m, n, Acts::IntegrationTest::nBinsZ, and pos().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), ActsExamples::BField::txt::fieldMapperXYZ(), ActsExamples::BField::root::fieldMapperXYZ(), and Acts::IntegrationTest::readFieldXYZ().

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename cell_t >

void Acts::fillCluster	(	std::vector< std::vector< cell_t >> &	mergedCells,
		std::unordered_map< size_t, std::pair< cell_t, bool >> &	cellMap,
		size_t	index,
		size_t	nBins0,
		bool	commonCorner = true,
		double	energyCut = 0.
	)

fillCluster This function is a helper function internally used by Acts::createClusters. It does connected component labelling using a hash map in order to find out which cells are neighbours. This function is called recursively by all neighbours of the current cell. The function is templated on the digitization cell type to allow users to use their own implementation inheriting from Acts::DigitizationCell.

Template Parameters

Cell	the digitization cell

Parameters

[in,out]	mergedCells	the final vector of cells to which cells of one cluster should be added
[in,out]	cellMap	the hashmap of all present cells + a flag indicating if they have been added to a cluster already, with the key being the global grid index
[in]	index	the current global grid index of the cell
[in]	cellA	the current cell
[in]	nBins0	number of bins in direction 0
[in]	commonCorner	flag indicating if also cells sharing a common corner should be merged into one cluster
[in]	energyCut	possible energy cut to be applied

auto startSearchMap = std::chrono::system_clock::now();

Definition at line 41 of file Clusterization.ipp.

View newest version in sPHENIX GitHub at line 41 of file Clusterization.ipp

Referenced by createClusters().

Here is the caller graph for this function:

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

alternative implementation of 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

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 an alternative Logger instance to the default Acts logger. This instance prints the log output mirrored from right to left.

Returns

pointer to logging instance

Definition at line 55 of file Logger.cpp.

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

References name, and print().

Referenced by addCylinderLayerProtoMaterial(), addDiscLayerProtoMaterial(), Acts::Test::Layers::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), ActsExamples::Generic::buildDetector(), ActsExamples::TGeo::buildTGeoDetector(), Acts::CuboidVolumeBuilder::buildVolume(), convertDD4hepDetector(), Acts::Sycl::createSeedsForGroupSycl(), cylinderVolumeHelper_dd4hep(), ActsExamples::determineEventFilesRange(), Acts::ImpactPointEstimator< input_track_t, propagator_t, propagator_options_t >::estimate3DImpactParameters(), Acts::ImpactPointEstimator< input_track_t, propagator_t, propagator_options_t >::estimateImpactParameters(), AlignedDetector::finalize(), PayloadDetector::finalize(), PHActsVertexFinder::findVertices(), PHActsInitialVertexFinder::findVertices(), PHActsVertexFitter::fitVertex(), Acts::Sycl::QueueWrapper::initialize(), Acts::Test::LayerCreatorFixture::LayerCreatorFixture(), Acts::HelicalTrackLinearizer< propagator_t, propagator_options_t >::linearizeTrack(), PHActsTrkFitter::loopTracks(), main(), MakeActsGeometry::makeGeometry(), Acts::VolumeMaterialMapper::mapMaterialTrack(), Acts::SurfaceMaterialMapper::mapMaterialTrack(), materialMappingExample(), Acts::Test::CubicTrackingGeometry::operator()(), Acts::Test::CylindricalTrackingGeometry::operator()(), processGeometry(), PHActsVertexPropagator::propagateTrack(), PHActsTrackProjection::propagateTrack(), PHTpcResiduals::propagateTrackState(), ActsExamples::Options::readFatrasConfig(), ActsExamples::Sequencer::run(), Acts::EventDataView3DTest::testMultiTrajectory(), trackingGeometry(), Acts::detail::transformFreeToBoundParameters(), and volumeBuilder_dd4hep().

Here is the call graph for this function:

Here is the caller graph for this function:

LoggerWrapper Acts::getDummyLogger

(

)

Definition at line 68 of file Logger.cpp.

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

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), BOOST_DATA_TEST_CASE(), main(), Acts::Test::runTest(), transportFreely(), and transportToSurface().

Here is the caller graph for this function:

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

(

Acts::BinningValue &

type

)

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

Parameters

[in]

Type

of bin

Returns

a coordinate transform function

Definition at line 73 of file MaterialGridHelper.cpp.

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

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

Referenced by createGrid2D(), and createGrid3D().

Here is the call graph for this function:

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 charm_jet_strange_helicity::N, Acts::PrimitivesView3DTest::run(), and T.

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

Here is the call graph for this function:

Here is the caller graph for this function:

const detail::KalmanFitterErrorCategory& Acts::KalmanFitterErrorCategory ( )

inline

Definition at line 53 of file KalmanFitterError.hpp.

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

References c.

std::error_code Acts::make_error_code ( Acts::SurfaceError  e )

inline

Definition at line 43 of file SurfaceError.hpp.

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

References Acts::UnitConstants::e.

std::error_code Acts::make_error_code ( Acts::PropagatorError  e )

inline

Definition at line 51 of file PropagatorError.hpp.

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

References Acts::UnitConstants::e.

std::error_code Acts::make_error_code ( Acts::EigenStepperError  e )

inline

Definition at line 52 of file EigenStepperError.hpp.

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

References Acts::UnitConstants::e.

std::error_code Acts::make_error_code ( Acts::KalmanFitterError  e )

inline

Definition at line 58 of file KalmanFitterError.hpp.

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

References Acts::UnitConstants::e.

std::error_code Acts::make_error_code ( Acts::VertexingError  e )

inline

Definition at line 60 of file VertexingError.hpp.

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

References Acts::UnitConstants::e.

std::error_code Acts::make_error_code ( Acts::CombinatorialKalmanFilterError  e )

inline

Definition at line 64 of file CombinatorialKalmanFilterError.hpp.

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

References 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 534 of file BoundingBox.ipp.

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

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

Referenced by gridBoxFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

constexpr PdgParticle Acts::makeAbsolutePdgParticle ( PdgParticle  pdg )

inline

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

Definition at line 36 of file PdgParticle.hpp.

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

References pdg, and value.

Referenced by ActsFatras::AbsPdgSelector< Pdg >::operator()(), and ActsFatras::AbsPdgExcluder< Pdg >::operator()().

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 66 of file UnitVectors.hpp.

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

References epsilon.

Referenced by makeCurvilinearUnitVectors(), and ActsFatras::detail::Scattering< 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 108 of file UnitVectors.hpp.

View newest version in sPHENIX GitHub at line 108 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:

template<typename T >

ActsVector<T, 3> Acts::makeDirectionUnitFromPhiEta ( 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 explicitely cast missmatched input types.

Definition at line 29 of file UnitVectors.hpp.

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

References cos().

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

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ActsVector<T, 3> Acts::makeDirectionUnitFromPhiTheta ( 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 explicitely cast missmatched input types.

Definition at line 48 of file UnitVectors.hpp.

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

References cos().

Referenced by BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), Acts::SingleBoundTrackParameters< SinglyCharged >::fourPosition(), Acts::SingleBoundTrackParameters< SinglyCharged >::position(), Acts::SingleFreeTrackParameters< charge_t >::SingleFreeTrackParameters(), Acts::detail::transformBoundToFreeParameters(), and Acts::SingleBoundTrackParameters< SinglyCharged >::unitDirection().

Here is the call graph for this function:

Here is the caller graph for this function:

Acts::MaterialGrid2D Acts::mapMaterialPoints	(	Acts::Grid2D &	grid,
		const Acts::RecordedMaterialVolumePoint &	mPoints,
		std::function< Acts::Vector2D(Acts::Vector3D)> &	transfoGlobalToLocal
	)

Concatenate a set of material at arbitrary space points on a set of grid points and produces a grid containing the averaged material values.

Parameters

[in]	grid	The material collecting grid
[in]	mPoints	The set of material at the space points
[in]	transfoGlobalToLocal	tranformation from local to local coordinate

Returns

The average material grid decomposed into classification numbers

Definition at line 216 of file MaterialGridHelper.cpp.

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

References Acts::detail::Grid< T, Axes >::at(), Acts::detail::Grid< T, Axes >::atLocalBins(), Acts::detail::Grid< T, Axes >::localBinsFromLowerLeftEdge(), max, Acts::detail::Grid< T, Axes >::maxPosition(), 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:

Acts::MaterialGrid3D Acts::mapMaterialPoints	(	Acts::Grid3D &	grid,
		const Acts::RecordedMaterialVolumePoint &	mPoints,
		std::function< Acts::Vector3D(Acts::Vector3D)> &	transfoGlobalToLocal
	)

Concatenate a set of material at arbitrary space points on a set of grid points and produces a grid containing the averaged material values.

Parameters

[in]	grid	The material collecting grid
[in]	mPoints	The set of material at the space points
[in]	transfoGlobalToLocal	tranformation from local to local coordinate

Returns

The average material grid decomposed into classification numbers

Definition at line 248 of file MaterialGridHelper.cpp.

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

References Acts::detail::Grid< T, Axes >::at(), Acts::detail::Grid< T, Axes >::atLocalBins(), Acts::detail::Grid< T, Axes >::localBinsFromLowerLeftEdge(), max, Acts::detail::Grid< T, Axes >::maxPosition(), min, Acts::detail::Grid< T, Axes >::minPosition(), Acts::detail::Grid< T, Axes >::numLocalBins(), and Acts::detail::Grid< T, Axes >::size().

Here is the call 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,
		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: 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 21 of file MaterialMapUtils.cpp.

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

References material(), max, Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), and pos().

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,
		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 103 of file MaterialMapUtils.cpp.

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

References k, material(), max, Acts::IntegrationTest::nBinsZ, and pos().

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 402 of file Helpers.hpp.

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

References p.

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

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

constexpr TrackStatePropMask Acts::operator&	(	TrackStatePropMask	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 44 of file TrackStatePropMask.hpp.

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

constexpr TrackStatePropMask& Acts::operator&=	(	TrackStatePropMask &	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 71 of file TrackStatePropMask.hpp.

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

std::ostream & Acts::operator<<	(	std::ostream &	os,
		Acts::PdgParticle	pdg
	)

Print PDG particle numbers with a descriptive name.

Note

This is a bit hacky since it modifies the namespace of another library (ActsCore). Since the core library does not need to contain the full particle data table, it can only be defined here. It also only extends the output and should not have any side effects. We are probably fine.

Definition at line 64 of file ParticleData.cpp.

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

References ActsFatras::findName(), name, and pdg.

Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os, const MinimalSourceLink &  sl  )

inline

Definition at line 47 of file MeasurementHelpers.hpp.

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

References Acts::MinimalSourceLink::meas.

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

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const GlueVolumesDescriptor &	gvd
	)

Definition at line 74 of file GlueVolumesDescriptor.cpp.

View newest version in sPHENIX GitHub at line 74 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 49 of file MaterialSlab.cpp.

View newest version in sPHENIX GitHub at line 49 of file MaterialSlab.cpp

References Acts::MaterialSlab::material(), 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 117 of file IVisualization3D.hpp.

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

References Acts::IVisualization3D::write().

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(), 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 &	os,
		GeometryIdentifier	id
	)

Definition at line 14 of file GeometryIdentifier.cpp.

View newest version in sPHENIX GitHub at line 14 of file GeometryIdentifier.cpp

std::ostream & Acts::operator<<	(	std::ostream &	sl,
		const Extent &	ext
	)

Overload of << operator for std::ostream for debug output.

Definition at line 24 of file Extent.cpp.

View newest version in sPHENIX GitHub at line 24 of file Extent.cpp

References Acts::Extent::toStream().

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 &	sl,
		const BinUtility &	bgen
	)

Overload of << operator for std::ostream for debug output.

Overload of << operator for std::ostream for debug output

Definition at line 14 of file BinUtility.cpp.

View newest version in sPHENIX GitHub at line 14 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 548 of file BoundingBox.ipp.

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

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 145 of file VolumeBounds.hpp.

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

References Acts::VolumeBounds::type(), and Acts::VolumeBounds::values().

Referenced by Acts::Surface::operator!=(), and nlohmann::detail::iter_impl< BasicJsonType >::operator!=().

Here is the call graph for this function:

Here is the caller graph for this function:

constexpr TrackStatePropMask Acts::operator^	(	TrackStatePropMask	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 51 of file TrackStatePropMask.hpp.

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

constexpr TrackStatePropMask& Acts::operator^=	(	TrackStatePropMask &	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 79 of file TrackStatePropMask.hpp.

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

constexpr TrackStatePropMask Acts::operator|	(	TrackStatePropMask	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 37 of file TrackStatePropMask.hpp.

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

constexpr TrackStatePropMask& Acts::operator|=	(	TrackStatePropMask &	lhs,
		TrackStatePropMask	rhs
	)

Definition at line 63 of file TrackStatePropMask.hpp.

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

constexpr TrackStatePropMask Acts::operator~

(

TrackStatePropMask

op

)

Definition at line 58 of file TrackStatePropMask.hpp.

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

const detail::PropagatorErrorCategory& Acts::PropagatorErrorCategory ( )

inline

Definition at line 46 of file PropagatorError.hpp.

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

References c.

static const RotationMatrix3D Acts::s_idRotationZinverse ( detail::_helper  )

static

static const Vector3D Acts::s_origin ( 0  , 0  , 0    )

static

origin position

Referenced by Acts::NavigationLayer::isOnLayer(), and Acts::Layer::isOnLayer().

Here is the caller graph for this function:

static const Vector2D Acts::s_origin2D ( 0.  , 0.    )

static

static const Vector3D Acts::s_xAxis ( 1  , 0  , 0    )

static

global x Axis;

static const Vector3D Acts::s_yAxis ( 0  , 1  , 0    )

static

global y Axis;

static const Vector3D Acts::s_zAxis ( 0  , 0  , 1    )

static

global z Axis;

Acts::InterpolatedBFieldMapper< Acts::detail::Grid< Acts::Vector2D, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis > > Acts::solenoidFieldMapper	(	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 mapper instance for use in interpolation.

Definition at line 252 of file BFieldMapUtils.cpp.

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

References kdfinder::abs(), Acts::SolenoidBField::getField(), min, Acts::IntegrationTest::nBinsR, Acts::IntegrationTest::nBinsZ, Acts::VectorHelpers::perp(), and pos().

Referenced by main(), and Acts::IntegrationTest::makeFieldMap().

Here is the call graph for this function:

Here is the caller graph for this function:

void Acts::sortDetElementsByID

(

std::vector< dd4hep::DetElement > &

det

)

Sort function which sorts dd4hep::DetElement by their ID

Parameters

[in]

out]

det the dd4hep::DetElements to be sorted

Definition at line 24 of file ConvertDD4hepDetector.hpp.

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

const detail::SurfaceErrorCategory& Acts::SurfaceErrorCategory ( )

inline

Definition at line 38 of file SurfaceError.hpp.

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

References c.

template<template< size_t > class Callable, size_t N, size_t NMAX, typename... Args>

decltype(Callable<N>::invoke(std::declval<Args>()...)) 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 paramater 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 356 of file Helpers.hpp.

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

References charm_jet_coverage::args, charm_jet_strange_helicity::N, NMAX, and v.

std::string Acts::toString ( const ActsMatrixXd &  matrix, int  precision = 4, const std::string &  offset = ""  )

inline

Print out a matrix in a structured way.

Parameters

matrix	The matrix to print
precision	Numeric output precision
offset	Offset in front of matrix lines

Returns

The printed string

Definition at line 237 of file Helpers.hpp.

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

References matrix(), offset, precision, and Acts::detail::roundWithPrecision().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::ActsExtension::getT(), Acts::Navigator::initialize(), and toString().

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Acts::toString ( const Acts::Translation3D &  translation, int  precision = 4  )

inline

Print out a translation in a structured way.

Parameters

matrix	The translation to print
precision	Numeric output precision

Returns

The printed string

Definition at line 280 of file Helpers.hpp.

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

References precision, and toString().

Here is the call graph for this function:

std::string Acts::toString ( const Acts::Transform3D &  transform, int  precision = 4, const std::string &  offset = ""  )

inline

Print out a transform in a structured way.

Parameters

matrix	The transform to print
precision	Numeric output precision
offset	Offset in front of matrix lines

Returns

The printed string

Definition at line 294 of file Helpers.hpp.

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

References offset, precision, and toString().

Here is the call graph for this function:

std::shared_ptr<const TrackingGeometry> Acts::trackingGeometry

(

)

create a small tracking geometry to map some dummy material on

Definition at line 29 of file SurfaceMaterialMapperTests.cpp.

View newest version in sPHENIX GitHub at line 29 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 BOOST_DATA_TEST_CASE(), ActsExamples::TGeo::buildTGeoDetector(), Acts::Navigator::inactive(), Acts::Navigator::initialize(), Acts::Navigator::initializeTarget(), main(), and Acts::TrackingGeometryBuilder::trackingGeometry().

Here is the call graph for this function:

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 311 of file Helpers.hpp.

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

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 327 of file Helpers.hpp.

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

const detail::VertexingErrorCategory& Acts::VertexingErrorCategory ( )

inline

Definition at line 55 of file VertexingError.hpp.

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

References c.

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 93 of file MeasurementHelpers.hpp.

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

References Acts::Test::cov, and Acts::Test::dim.

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::GainMatrixUpdater::operator()(), and Acts::Test::MinimalOutlierFinder::operator()().

Here is the caller graph for this function:

std::shared_ptr< const CylinderVolumeBuilder > Acts::volumeBuilder_dd4hep	(	dd4hep::DetElement	subDetector,
		Logging::Level	loggingLevel = Logging::Level::INFO,
		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]	worldDetElement	the DD4hep DetElement of the world
[in]	loggingLevel	is the debug logging level of the conversion and 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 inbetween 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 115 of file ConvertDD4hepDetector.cpp.

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

References ACTS_INFO, ACTS_LOCAL_LOGGER, 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, closed, Acts::UnitConstants::cm, collectCompounds_dd4hep(), collectLayers_dd4hep(), collectVolumes_dd4hep(), Acts::DD4hepLayerBuilder::Config::configurationName, Acts::DD4hepVolumeBuilder::Config::configurationName, createProtoMaterial(), Acts::CylinderVolumeBuilder::Config::ctVolumeBuilder, cylinderVolumeHelper_dd4hep(), Acts::UnitConstants::e, getDefaultLogger(), Acts::ActsExtension::hasType(), Acts::ActsExtension::hasValue(), Acts::CylinderVolumeBuilder::Config::layerBuilder, Acts::CylinderVolumeBuilder::Config::layerEnvelopeR, Acts::CylinderVolumeBuilder::Config::layerEnvelopeZ, Acts::PassiveLayerBuilder::Config::layerIdentification, open, Acts::LayerCreator::Config::surfaceArrayCreator, Acts::CylinderVolumeBuilder::Config::trackingVolumeHelper, 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:

void Acts::xmlToProtoSurfaceMaterial	(	const xml_comp_t &	x_material,
		ActsExtension &	actsExtension,
		const std::string &	baseTag
	)

Helper method that decorates an ActsExtension with proto material description for boundaries

• it assigns bins for inner / representing / outer Helper method that decorates an ActsExtension with proto material description,
• it assigns bins for inner / representing / outer

Parameters

x_material	the material tag to be inspected
actsExtension	the extension that is augmented
baseTag	the xml tag to be checked

Definition at line 102 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 102 of file ConvertDD4hepMaterial.cpp

References Acts::ActsExtension::addType(), Acts::ActsExtension::addValue(), Acts::Test::mSurface, and n.

Referenced by create_element().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Transform3D Acts::aTransform

Initial value:

= Transform3D::Identity() *
                         Translation3D(30_cm, 7_m, -87_mm) *
                         AngleAxis3D(0.42, Vector3D(-3., 1., 8).normalized())

Definition at line 31 of file SurfaceIntersectionTests.cpp.

View newest version in sPHENIX GitHub at line 31 of file SurfaceIntersectionTests.cpp

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

const std::vector<std::string> Acts::binningValueNames

static

Initial value:

= {
    "binX",    "binY", "binZ",   "binR",  "binPhi",
    "binRPhi", "binH", "binEta", "binMag"}

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(), Acts::JsonGeometryConverter::jsonToBinUtility(), Acts::ProtoLayerHelper::protoLayers(), Acts::JsonGeometryConverter::surfaceMaterialToJson(), and Acts::Extent::toStream().

template<typename fitter >

constexpr bool Acts::LinearizerConcept

Initial value:

=
    Acts::Concepts ::Linearizer::LinearizerConcept<fitter>::value

Definition at line 58 of file LinearizerConcept.hpp.

View newest version in sPHENIX GitHub at line 58 of file LinearizerConcept.hpp

constexpr int Acts::PolygonDynamic = -1

Tag to trigger specialization of a dynamic polygon.

Definition at line 131 of file ConvexPolygonBounds.hpp.

View newest version in sPHENIX GitHub at line 131 of file ConvexPolygonBounds.hpp

constexpr double 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 36 of file Definitions.hpp.

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

Referenced by Acts::PlaneSurface::PlaneSurface().

constexpr double Acts::s_epsilon = 3 * std::numeric_limits<double>::epsilon()

static

Tolerance for bein numerical equal for geometry building.

Definition at line 24 of file Definitions.hpp.

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

Referenced by Acts::Test::basicChecks(), 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::JsonGeometryConverter::DefaultBin(), Acts::detail::IntersectionHelper2D::intersectEllipse(), Acts::detail::IntersectionHelper2D::intersectSegment(), Acts::TGeoSurfaceConverter::planeComponents(), and Acts::PlaneSurface::polyhedronRepresentation().

const Rotation3D Acts::s_idRotation

static

Initial value:

=
    Rotation3D::Identity()

idendity rotation

Definition at line 20 of file GeometryStatics.hpp.

View newest version in sPHENIX GitHub at line 20 of file GeometryStatics.hpp

const Transform3D Acts::s_idTransform

static

Initial value:

=
    Transform3D::Identity()

idendity transformation

Definition at line 18 of file GeometryStatics.hpp.

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

Referenced by Acts::PassiveLayerBuilder::centralLayers(), Acts::LayerCreator::cylinderLayer(), Acts::LayerCreator::discLayer(), Acts::CylinderVolumeHelper::estimateAndCheckDimension(), Acts::CylinderVolumeHelper::glueTrackingVolumes(), and Acts::LayerCreator::planeLayer().

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_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 unneccessarily. With the native length unit of mm this corresponds to 0.1um.

Definition at line 31 of file Definitions.hpp.

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

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), Acts::TrackingVolume::compatibleBoundaries(), Acts::Test::consistencyCheck(), Acts::AnnulusBounds::coversFullAzimuth(), Acts::detail::VerticesHelper::ellipsoidVertices(), Acts::PlaneSurface::globalToLocal(), Acts::ConeSurface::globalToLocal(), Acts::ConeVolumeBounds::inside(), Acts::CylinderBounds::inside3D(), Acts::PlanarHelper::intersect(), Acts::ConeSurface::intersect(), Acts::CylinderSurface::intersect(), Acts::LineSurface::intersect(), Acts::Test::PropagatorState::Stepper::overstepLimit(), Acts::StraightLineStepper::overstepLimit(), Acts::ConeSurface::polyhedronRepresentation(), Acts::Navigator::resolveSurfaces(), and Acts::Layer::surfaceOnApproach().

const Transform3D Acts::s_planeXY = Transform3D::Identity()

static

Definition at line 32 of file VolumeBounds.hpp.

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

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

const Transform3D Acts::s_planeYZ

static

Initial value:

=
    AngleAxis3D(0.5 * M_PI, Vector3D::UnitY()) *
    AngleAxis3D(0.5 * M_PI, Vector3D::UnitZ()) * Transform3D::Identity()

Definition at line 33 of file VolumeBounds.hpp.

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

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::CuboidVolumeBounds::orientedSurfaces(), and Acts::TrapezoidVolumeBounds::orientedSurfaces().

const Transform3D Acts::s_planeZX

static

Initial value:

=
    AngleAxis3D(-0.5 * M_PI, Vector3D::UnitX()) *
    AngleAxis3D(-0.5 * M_PI, Vector3D::UnitZ()) * Transform3D::Identity()

Definition at line 36 of file VolumeBounds.hpp.

View newest version in sPHENIX GitHub at line 36 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 31 of file EventDataView3D.hpp.

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

ViewConfig Acts::s_viewGrid = ViewConfig({220, 0, 0})

static

Definition at line 28 of file GeometryView3D.hpp.

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

ViewConfig Acts::s_viewLine = ViewConfig({0, 0, 220})

static

Definition at line 29 of file GeometryView3D.hpp.

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

ViewConfig Acts::s_viewMeasurement = ViewConfig({255, 102, 0})

static

Definition at line 29 of file EventDataView3D.hpp.

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

ViewConfig Acts::s_viewParameter = ViewConfig({0, 0, 255})

static

Definition at line 28 of file EventDataView3D.hpp.

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

ViewConfig Acts::s_viewPassive = ViewConfig({240, 280, 0})

static

Definition at line 26 of file GeometryView3D.hpp.

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

ViewConfig Acts::s_viewPredicted = ViewConfig({51, 204, 51})

static

Definition at line 30 of file EventDataView3D.hpp.

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

ViewConfig Acts::s_viewSensitive = ViewConfig({0, 180, 240})

static

Definition at line 25 of file GeometryView3D.hpp.

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

Referenced by Acts::SurfaceView3DTest::run().

ViewConfig Acts::s_viewSmoothed = ViewConfig({0, 102, 255})

static

Definition at line 32 of file EventDataView3D.hpp.

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

ViewConfig Acts::s_viewVolume = ViewConfig({220, 220, 0})

static

Definition at line 27 of file GeometryView3D.hpp.

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

Referenced by Acts::VolumeView3DTest::run().

template<typename T >

constexpr bool Acts::SourceLinkConcept

Initial value:

=
    Concepts ::detail_slc::SourceLinkConcept<T>::value

Definition at line 56 of file SourceLinkConcept.hpp.

View newest version in sPHENIX GitHub at line 56 of file SourceLinkConcept.hpp

template<typename stepper , typename state = typename stepper::State>

constexpr bool Acts::StepperConcept

Initial value:

=
    Acts::Concepts ::Stepper::StepperConcept<stepper, state>::value

Definition at line 155 of file StepperConcept.hpp.

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

template<typename stepper >

constexpr bool Acts::StepperStateConcept

Initial value:

=
    Acts::Concepts ::Stepper::StepperStateConcept<stepper>

Definition at line 158 of file StepperConcept.hpp.

View newest version in sPHENIX GitHub at line 158 of file StepperConcept.hpp

GeometryContext Acts::tgContext = GeometryContext()

Definition at line 25 of file ConeVolumeBoundsTests.cpp.

View newest version in sPHENIX GitHub at line 25 of file ConeVolumeBoundsTests.cpp

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), BOOST_DATA_TEST_CASE(), Acts::Test::PropagatorState::Stepper::boundState(), Acts::Test::intersectionTest(), main(), Acts::Test::runTest(), Acts::Test::testJacobianToGlobal(), and Acts::EventDataView3DTest::testMultiTrajectory().

std::shared_ptr<const TrackingGeometry> Acts::tGeometry = trackingGeometry()

Definition at line 94 of file SurfaceMaterialMapperTests.cpp.

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

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

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