ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Acts Namespace Reference

Set the Geometry Context PLUGIN. More...

Namespaces

namespace  concept
 
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  EventDataVisualization
 
namespace  IntegrationTest
 
namespace  KalmanVertexTrackUpdater
 
namespace  KalmanVertexUpdater
 
namespace  Legacy
 
namespace  Logging
 debug output related helper classes and functions
 
namespace  MeasurementHelpers
 
namespace  PlanarHelper
 Helpers for planar surfaces that share the same maths.
 
namespace  PrimitivesVisualization
 
namespace  SurfaceVisualization
 
namespace  Test
 Namespace for ATS unit tests.
 
namespace  TGeoPrimitivesHelpers
 
namespace  TrackStatePropMask
 
namespace  UnitConstants
 
namespace  UnitLiterals
 
namespace  units
 Legacy namespace for backward-compatibility.
 
namespace  VectorHelpers
 
namespace  Visualization
 
namespace  VolumeVisualization
 

Classes

class  ChargedPolicy
 policy class for charged particles/tracks More...
 
class  NeutralPolicy
 policy class for neutral particles/tracks More...
 
class  Measurement
 base class for Measurements More...
 
struct  fittable_measurement_helper
 
struct  MinimalSourceLink
 
class  MultiTrajectory
 
class  ParameterSet
 Description of a set of (local) parameters. More...
 
class  SingleBoundTrackParameters
 Charged and Neutrial Track Parameterisation classes bound to to a reference surface. This is a single-component representation. More...
 
class  SingleCurvilinearTrackParameters
 Charged and Neutrial Curvilinear Track representation This is a single-component representation. More...
 
class  SingleFreeParameters
 Container class for free parameters. More...
 
class  SingleTrackParameters
 base class for a single set of track parameters More...
 
class  TrackState
 Templated class to hold the track information on a surface along the trajectory. More...
 
struct  TrackStatePathLengthSorter
 
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  AbstractVolume
 
class  ApproachDescriptor
 
class  BoundarySurfaceT
 
class  ConeLayer
 
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  GeometryID
 
class  GeometryObject
 
class  ObjectSorterT
 
class  DistanceSorterT
 
class  GeometryObjectSorterT
 
class  GlueVolumesDescriptor
 
class  HierarchicalGeometryContainer
 
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  SurfaceArrayCreator
 
class  TrackingGeometry
 
class  TrackingGeometryBuilder
 
class  TrackingVolume
 
class  TrackingVolumeArrayCreator
 
class  TrapezoidVolumeBounds
 
class  Volume
 
class  VolumeBounds
 
exception  ConstantBField
 returns a given constant field value at every point More...
 
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  AccumulatedMaterialProperties
 AccumulatedMaterialProperties. More...
 
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  MaterialProperties
 
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  DebugOutputActor
 
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  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
 
struct  SeedFilterConfig
 
class  SeedFilter
 
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  CKFSourceLinkSelector
 This struct selects those source links compatible with the given track parameter against provided criteria. 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...
 
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  MultiIndex
 
struct  unbound_parameter
 type for parameters with unrestricted value range More...
 
struct  local_parameter
 type for local parameters bound to a surface More...
 
struct  bound_parameter
 type for parameter with restricted value range More...
 
struct  cyclic_parameter
 type for parameter with cyclic value range More...
 
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  GaussianTrackDensity
 Class to model tracks as 2D Gaussian-shaped density functions based on their d0 and z0 perigee parameters (mean value) and covariance matrices (determining the width of the function) 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  TrackDensity
 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  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...
 
class  IVisualization
 
class  ObjVisualization
 
class  PlyVisualization
 Helper to write out PlyVisualization visualization format. More...
 
class  MaterialWiper
 
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  JsonGeometryConverter
 read the material from Json More...
 
class  JsonMaterialDecorator
 Material decorator from Json format. More...
 
class  ITGeoIdentifierProvider
 ITGeoIdentierProvider. More...
 
class  TGeoDetectorElement
 
class  TGeoLayerBuilder
 
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
 FittableMeasurement variant type.
 
using NeutralParameters = SingleTrackParameters< NeutralPolicy >
 
using NeutralCurvilinearParameters = SingleCurvilinearTrackParameters< NeutralPolicy >
 
using NeutralBoundParameters = SingleBoundTrackParameters< NeutralPolicy >
 
using NeutralFreeParameters = SingleFreeParameters< NeutralPolicy >
 
using TrackParameters = SingleTrackParameters< ChargedPolicy >
 
using CurvilinearParameters = SingleCurvilinearTrackParameters< ChargedPolicy >
 
using BoundParameters = SingleBoundTrackParameters< ChargedPolicy >
 
using FreeParameters = SingleFreeParameters< ChargedPolicy >
 
using TrackStateType = std::bitset< TrackStateFlag::NumTrackStateFlags >
 
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 SurfacePtrVector = std::vector< SurfacePtr >
 
using MagneticFieldContext = std::any
 This is the central definition of the Acts payload object regarding magnetic field status.
 
using RecordedMaterialPoint = std::vector< std::pair< Acts::MaterialProperties, Acts::Vector3D >>
 list of point used in the mapping of a surface
 
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::ActsVectorF< 5 >, EAxis, EAxis >
 
using MaterialGrid3D = Acts::detail::Grid< Acts::ActsVectorF< 5 >, EAxis, EAxis, EAxis >
 
using MaterialPropertiesVector = std::vector< MaterialProperties >
 
using MaterialPropertiesMatrix = std::vector< MaterialPropertiesVector >
 
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 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 Rotation3D = Eigen::Quaternion< double >
 
using Translation3D = Eigen::Translation< double, 3 >
 
using AngleAxis3D = Eigen::AngleAxisd
 
using Transform3D = Eigen::Affine3d
 
using Vector3D = Eigen::Matrix< double, 3, 1 >
 
using Vector2D = Eigen::Matrix< double, 2, 1 >
 
using RotationMatrix3D = Eigen::Matrix< double, 3, 3 >
 
using Rotation3F = Eigen::Quaternion< float >
 
using Translation3F = Eigen::Translation< float, 3 >
 
using AngleAxis3F = Eigen::AngleAxisf
 
using Transform3F = Eigen::Affine3f
 
using Vector3F = Eigen::Matrix< float, 3, 1 >
 
using Vector2F = Eigen::Matrix< float, 2, 1 >
 
using RotationMatrix3F = Eigen::Matrix< float, 3, 3 >
 
using BoundParametersScalar = double
 Underlying fundamental scalar type for bound track parameters.
 
using FreeParametersScalar = double
 Underlying fundamental scalar type for free track parameters.
 
using SpacePointScalar = double
 Underlying fundamental scalar type for space points.
 
template<BoundParametersIndices kIndex>
using BoundParameterType = typename detail::BoundParameterTraits< kIndex >::type
 
using BoundVector = ActsVector< BoundParametersScalar, eBoundParametersSize >
 
using BoundRowVector = ActsRowVector< BoundParametersScalar, eBoundParametersSize >
 
using BoundMatrix = ActsMatrix< BoundParametersScalar, eBoundParametersSize, eBoundParametersSize >
 
using BoundSymMatrix = ActsSymMatrix< BoundParametersScalar, eBoundParametersSize >
 
using FreeVector = ActsVector< FreeParametersScalar, eFreeParametersSize >
 
using FreeRowVector = ActsRowVector< FreeParametersScalar, eFreeParametersSize >
 
using FreeMatrix = ActsMatrix< FreeParametersScalar, eFreeParametersSize, eFreeParametersSize >
 
using FreeSymMatrix = ActsSymMatrix< FreeParametersScalar, eFreeParametersSize >
 
using SpacePointVector = ActsVector< SpacePointScalar, eSpacePointSize >
 
using SpacePointRowVector = ActsRowVector< SpacePointScalar, eSpacePointSize >
 
using SpacePointSymMatrix = ActsMatrix< SpacePointScalar, eSpacePointSize, eSpacePointSize >
 
using FreeToBoundMatrix = ActsMatrix< BoundParametersScalar, eBoundParametersSize, eFreeParametersSize >
 
using SpacePointToBoundMatrix = ActsMatrix< BoundParametersScalar, eBoundParametersSize, eSpacePointSize >
 
using BoundToFreeMatrix = ActsMatrix< FreeParametersScalar, eFreeParametersSize, eBoundParametersSize >
 
using SpacePointToFreeMatrix = ActsMatrix< FreeParametersScalar, eFreeParametersSize, eSpacePointSize >
 
using BoundToSpacePointMatrix = ActsMatrix< SpacePointScalar, eSpacePointSize, eBoundParametersSize >
 
using FreeToSpacePointMatrix = ActsMatrix< SpacePointScalar, eSpacePointSize, eFreeParametersSize >
 
using ParDef = BoundParametersIndices
 
using ParID_t = BoundParametersIndices
 
using ParValue_t = BoundParametersScalar
 
using Ray3F = Ray< float, 3 >
 
using Ray3D = Ray< double, 3 >
 
using SurfaceMaterialMap = std::map< GeometryID, std::shared_ptr< const ISurfaceMaterial >>
 
using VolumeMaterialMap = std::map< GeometryID, std::shared_ptr< const IVolumeMaterial >>
 
using DetectorMaterialMaps = std::pair< SurfaceMaterialMap, VolumeMaterialMap >
 
template<ParID_t... params>
using Measurement_t = Measurement< Identifier, params...>
 
using NodeTransform = std::pair< TGeoNode *, std::shared_ptr< const Transform3D >>
 
using IdentifiedPolyderon = std::tuple< std::string, bool, Polyhedron >
 

Enumerations

enum  TrackStateFlag {
  MeasurementFlag = 0, ParameterFlag = 1, OutlierFlag = 2, HoleFlag = 3,
  MaterialFlag = 4, NumTrackStateFlags = 5
}
 
enum  KalmanFitterError
 
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  BoundaryOrientation { insideVolume = -1, outsideVolume = 1 }
 specify the inside/outside with respect to the normal vector More...
 
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  CombinatorialKalmanFilterError
 
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  AxisDefs : int {
  eX = 0, eY = 1, eZ = 2, ePX = 0,
  ePY = 1, ePZ = 2
}
 
enum  BoundParametersIndices : unsigned int {
  eBoundLoc0 = 0, eBoundLoc1 = 1, eBoundPhi = 2, eBoundTheta = 3,
  eBoundQOverP = 4, eBoundTime = 5, eBoundParametersSize, eLOC_0 = eBoundLoc0,
  eLOC_1 = eBoundLoc1, eLOC_R = eLOC_0, eLOC_PHI = eLOC_1, eLOC_X = eLOC_0,
  eLOC_Y = eLOC_1, eLOC_RPHI = eLOC_0, eLOC_Z = eLOC_1, eLOC_D0 = eLOC_0,
  eLOC_Z0 = eLOC_1, ePHI = eBoundPhi, eTHETA = eBoundTheta, eQOP = eBoundQOverP,
  eT = eBoundTime
}
 
enum  FreeParametersIndices : unsigned int {
  eFreePos0 = 0u, eFreePos1 = eFreePos0 + 1u, eFreePos2 = eFreePos0 + 2u, eFreeTime = 3u,
  eFreeDir0 = 4u, eFreeDir1 = eFreeDir0 + 1u, eFreeDir2 = eFreeDir0 + 2u, eFreeQOverP = 7u,
  eFreeParametersSize
}
 
enum  SpacePointIndices : unsigned int {
  eSpacePos0 = 0u, eSpacePos1 = eSpacePos0 + 1u, eSpacePos2 = eSpacePos0 + 2u, eSpaceTime = 3u,
  eSpacePointSize, eSpaceMom0 = eSpacePos0, eSpaceMom1 = eSpacePos1, eSpaceMom2 = eSpacePos2,
  eSpaceEnergy = eSpaceTime
}
 
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)
 
const
detail::KalmanFitterErrorCategory
KalmanFitterErrorCategory ()
 
std::error_code make_error_code (Acts::KalmanFitterError e)
 
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, GeometryID 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 MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float deriveEnergyLossBetheQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossLandau (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float deriveEnergyLossLandauQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossLandauSigma (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossLandauSigmaQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossRadiative (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float deriveEnergyLossRadiativeQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossMean (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float deriveEnergyLossMeanQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeEnergyLossMode (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float deriveEnergyLossModeQOverP (const MaterialProperties &slab, int pdg, float m, float qOverP, float q=UnitConstants::e)
 
float computeMultipleScatteringTheta0 (const MaterialProperties &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::RecordedMaterialPoint &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::RecordedMaterialPoint &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 MaterialProperties &materialProperties)
 
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)
 
template<typename propagator_state_t >
void targetDebugLog (propagator_state_t &state, const std::string &status, const std::function< std::string()> &logAction)
 
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::CombinatorialKalmanFilterErrorCategory
CombinatorialKalmanFilterErrorCategory ()
 
std::error_code make_error_code (Acts::CombinatorialKalmanFilterError e)
 
BinUtility adjustBinUtility (const BinUtility &bu, const RadialBounds &rBounds)
 adjust the BinUtility bu to the dimensions of radial bounds
 
BinUtility adjustBinUtility (const BinUtility &bu, const CylinderBounds &cBounds)
 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)
 adjust the BinUtility bu to the dimensions of cylinder volume bounds
 
BinUtility adjustBinUtility (const BinUtility &bu, const CuboidVolumeBounds &cBounds)
 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 LoggergetDefaultLogger (const std::string &name, const Logging::Level &lvl, std::ostream *log_stream=&std::cout)
 get default debug output logger
 
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 IVisualization &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 parameters_t >
constexpr bool ParameterConcept
 
template<typename T >
constexpr bool SourceLinkConcept
 
static const Transform3D s_idTransform
 idendity transformation
 
static const Rotation3D s_idRotation
 idendity rotation
 
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
 
std::shared_ptr< const
TrackingGeometry
tGeometry = trackingGeometry()
 
GeometryContext tgContext = GeometryContext()
 
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
NSize of the tuple obs_tuple
propagator_state_tType of the state of the propagation
stepper_tType of the stepper
TTypes of the extensions
Parameters
obs_tupleExtendable tuple of extensions
stateState of the propagation
stepperStepper of the propagation
bidsList that collects bids about validity of an extension for an upcoming step
validExtensionsList of valid extensions that will be used
knewk_1 - k_4 that is about to be evaluated in the upcoming call
bFieldB-field at a certain point
iDefines the calculation of knew=k_{i+1}
hDistance to the starting point k_1
kprevk_i that is used for the evaluation for knew
DTransport matrix of the jacobian

Geometry primitives helper functions

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::AngleAxis3D = typedef Eigen::AngleAxisd

Definition at line 116 of file Definitions.hpp.

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

using Acts::AngleAxis3F = typedef Eigen::AngleAxisf

Definition at line 124 of file Definitions.hpp.

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

Definition at line 56 of file TrackingVolume.hpp.

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

Definition at line 55 of file TrackingVolume.hpp.

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

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

Definition at line 23 of file AbstractVolume.hpp.

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

Definition at line 255 of file ParameterDefinitions.hpp.

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

Definition at line 19 of file TrackParameters.hpp.

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

using Acts::BoundParametersScalar = typedef double

Underlying fundamental scalar type for bound track parameters.

Definition at line 133 of file ParameterDefinitions.hpp.

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

template<BoundParametersIndices kIndex>
using Acts::BoundParameterType = typedef typename detail::BoundParameterTraits<kIndex>::type

Single bound track parameter type for value constrains.

The singular name is not a typo since this describes individual components.

Definition at line 244 of file ParameterDefinitions.hpp.

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

Definition at line 253 of file ParameterDefinitions.hpp.

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

Definition at line 257 of file ParameterDefinitions.hpp.

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

Definition at line 293 of file ParameterDefinitions.hpp.

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

Definition at line 303 of file ParameterDefinitions.hpp.

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

Definition at line 251 of file ParameterDefinitions.hpp.

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

Definition at line 18 of file TrackParameters.hpp.

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

Definition at line 26 of file IMaterialWriter.hpp.

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

Definition at line 24 of file MaterialGridHelper.hpp.

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

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

FittableMeasurement variant type.

Definition at line 313 of file Measurement.hpp.

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

Definition at line 264 of file ParameterDefinitions.hpp.

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

Definition at line 20 of file TrackParameters.hpp.

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

using Acts::FreeParametersScalar = typedef double

Underlying fundamental scalar type for free track parameters.

Definition at line 135 of file ParameterDefinitions.hpp.

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

Definition at line 262 of file ParameterDefinitions.hpp.

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

Definition at line 265 of file ParameterDefinitions.hpp.

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

Definition at line 282 of file ParameterDefinitions.hpp.

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

Definition at line 305 of file ParameterDefinitions.hpp.

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

Definition at line 261 of file ParameterDefinitions.hpp.

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

Definition at line 26 of file MaterialGridHelper.hpp.

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

Definition at line 28 of file MaterialGridHelper.hpp.

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

typedef std::tuple< std::string, bool, Polyhedron > Acts::IdentifiedPolyderon

Definition at line 22 of file ObjTestWriter.hpp.

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

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 26 of file ILayerArrayCreator.hpp.

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

Definition at line 52 of file TrackingVolume.hpp.

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

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

A std::shared_ptr to a Layer.

Definition at line 24 of file ILayerArrayCreator.hpp.

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

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

A vector of std::shared_ptr to layers.

Definition at line 28 of file ILayerArrayCreator.hpp.

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

Definition at line 29 of file MaterialGridHelper.hpp.

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

Definition at line 31 of file MaterialGridHelper.hpp.

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

Definition at line 98 of file MaterialProperties.hpp.

View newest version in sPHENIX GitHub at line 98 of file MaterialProperties.hpp

using Acts::MaterialPropertiesVector = typedef std::vector<MaterialProperties>

Definition at line 97 of file MaterialProperties.hpp.

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

template<ParID_t... params>
using Acts::Measurement_t = typedef Measurement<Identifier, 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 45 of file Layer.hpp.

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

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

Definition at line 20 of file IConfinedTrackingVolumeBuilder.hpp.

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

Definition at line 21 of file IConfinedTrackingVolumeBuilder.hpp.

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

Definition at line 20 of file NeutralParameters.hpp.

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

Definition at line 19 of file NeutralParameters.hpp.

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

Definition at line 21 of file NeutralParameters.hpp.

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

Definition at line 17 of file NeutralParameters.hpp.

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

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

Definition at line 46 of file Layer.hpp.

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

using Acts::NodeTransform = typedef std::pair<TGeoNode*, std::shared_ptr<const Transform3D>>

Definition at line 32 of file TGeoLayerBuilder.hpp.

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

Definition at line 309 of file ParameterDefinitions.hpp.

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

Definition at line 310 of file ParameterDefinitions.hpp.

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

Definition at line 311 of file ParameterDefinitions.hpp.

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

Using some short hands for Recorded Material.

Definition at line 266 of file MaterialInteractor.hpp.

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

using Acts::RecordedMaterialPoint = typedef std::vector<std::pair<Acts::MaterialProperties, Acts::Vector3D>>

list of point used in the mapping of a surface

Definition at line 23 of file MaterialGridHelper.hpp.

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

And recorded material track

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

Definition at line 272 of file MaterialInteractor.hpp.

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

using Acts::Rotation3D = typedef Eigen::Quaternion<double>

Definition at line 114 of file Definitions.hpp.

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

using Acts::Rotation3F = typedef Eigen::Quaternion<float>

Definition at line 122 of file Definitions.hpp.

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

using Acts::RotationMatrix3D = typedef Eigen::Matrix<double, 3, 3>

Definition at line 120 of file Definitions.hpp.

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

using Acts::RotationMatrix3F = typedef Eigen::Matrix<float, 3, 3>

Definition at line 128 of file Definitions.hpp.

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

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

Definition at line 270 of file ParameterDefinitions.hpp.

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

using Acts::SpacePointScalar = typedef double

Underlying fundamental scalar type for space points.

Definition at line 137 of file ParameterDefinitions.hpp.

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

Definition at line 272 of file ParameterDefinitions.hpp.

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

Definition at line 284 of file ParameterDefinitions.hpp.

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

Definition at line 295 of file ParameterDefinitions.hpp.

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

Definition at line 269 of file ParameterDefinitions.hpp.

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

Typedef of the surface intersection.

Definition at line 40 of file Layer.hpp.

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

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

Definition at line 32 of file SurfaceArrayCreator.hpp.

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

using Acts::SurfaceMaterialMap = typedef std::map<GeometryID, 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 35 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 26 of file VolumeBounds.hpp.

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

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

Definition at line 27 of file VolumeBounds.hpp.

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

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

Definition at line 34 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 24 of file GlueVolumesDescriptor.hpp.

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

Definition at line 42 of file TrackingVolume.hpp.

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

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

Definition at line 41 of file TrackingVolume.hpp.

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

Definition at line 26 of file TrackingVolumeArrayCreator.hpp.

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

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

A std::shared_ptr to a tracking volume.

Definition at line 23 of file GlueVolumesDescriptor.hpp.

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

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

Definition at line 31 of file ITrackingVolumeArrayCreator.hpp.

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

Definition at line 17 of file TrackParameters.hpp.

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

using Acts::TrackStateType = typedef std::bitset<TrackStateFlag::NumTrackStateFlags>

Definition at line 32 of file TrackState.hpp.

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

using Acts::Transform3D = typedef Eigen::Affine3d

Definition at line 117 of file Definitions.hpp.

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

using Acts::Transform3F = typedef Eigen::Affine3f

Definition at line 125 of file Definitions.hpp.

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

using Acts::Translation3D = typedef Eigen::Translation<double, 3>

Definition at line 115 of file Definitions.hpp.

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

using Acts::Translation3F = typedef Eigen::Translation<float, 3>

Definition at line 123 of file Definitions.hpp.

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

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

Definition at line 38 of file SurfaceArrayCreator.hpp.

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

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

Definition at line 37 of file SurfaceArrayCreator.hpp.

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

using Acts::Vector2D = typedef Eigen::Matrix<double, 2, 1>

Definition at line 119 of file Definitions.hpp.

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

using Acts::Vector2F = typedef Eigen::Matrix<float, 2, 1>

Definition at line 127 of file Definitions.hpp.

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

using Acts::Vector3D = typedef Eigen::Matrix<double, 3, 1>

Definition at line 118 of file Definitions.hpp.

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

using Acts::Vector3F = typedef Eigen::Matrix<float, 3, 1>

Definition at line 126 of file Definitions.hpp.

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

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

Definition at line 26 of file AbstractVolume.hpp.

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

using Acts::VolumeMaterialMap = typedef std::map<GeometryID, 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

axis defintion element for code readability

  • please use these for access to the member variables if needed, e.g. double z = position[Acts::eZ]; double px = momentum[Acts::ePX];
Enumerator:
eX 
eY 
eZ 
ePX 
ePY 
ePZ 

Definition at line 135 of file Definitions.hpp.

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

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

, 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

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

specify the inside/outside with respect to the normal vector

Enumerator:
insideVolume 
outsideVolume 

Definition at line 64 of file BoundarySurfaceFace.hpp.

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

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 31 of file BoundarySurfaceFace.hpp.

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

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 
eBoundParametersSize 
eLOC_0 
eLOC_1 
eLOC_R 
eLOC_PHI 
eLOC_X 
eLOC_Y 
eLOC_RPHI 
eLOC_Z 
eLOC_D0 
eLOC_Z0 
ePHI 
eTHETA 
eQOP 
eT 

Definition at line 39 of file ParameterDefinitions.hpp.

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

Definition at line 17 of file CombinatorialKalmanFilterError.hpp.

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

Definition at line 17 of file EigenStepperError.hpp.

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

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 
eFreeParametersSize 

Definition at line 87 of file ParameterDefinitions.hpp.

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

Definition at line 17 of file KalmanFitterError.hpp.

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

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

Enumerator:
navigation 
passive 
active 

Definition at line 52 of file Layer.hpp.

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

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

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

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

Definition at line 17 of file PropagatorError.hpp.

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

enum Acts::SpacePointIndices : unsigned int

Components of a space point 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.

Within the same context either the position-like or the momentum-like indices must be used exclusively.

Enumerator:
eSpacePos0 
eSpacePos1 
eSpacePos2 
eSpaceTime 
eSpacePointSize 
eSpaceMom0 
eSpaceMom1 
eSpaceMom2 
eSpaceEnergy 

Definition at line 116 of file ParameterDefinitions.hpp.

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

This enum describes the type of TrackState

Enumerator:
MeasurementFlag 
ParameterFlag 
OutlierFlag 
HoleFlag 
MaterialFlag 
NumTrackStateFlags 

Definition at line 23 of file TrackState.hpp.

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

Definition at line 17 of file VertexingError.hpp.

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

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 45 of file CylinderVolumeBuilder.hpp.

View newest version in sPHENIX GitHub at line 45 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
detElementthe DD4hep detector element for which this material is assigned
loggingLevelis the output level for the conversion
Returns
a map of the identification string and a surface material

Definition at line 86 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 86 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
detElementthe DD4hep detector element for which this material is assigned
loggingLevelis the output level for the conversion
Returns
a map of the identification string and a surface material

Definition at line 126 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 126 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
aExtensionthe ActsExtension for the binning parameters
layerthe Layer to assign the proto material
binningthe Binning prescription for the ActsExtension

Definition at line 52 of file ConvertDD4hepMaterial.cpp.

View newest version in sPHENIX GitHub at line 52 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 CylinderVolumeBounds &  cBounds 
)

adjust the BinUtility bu to the dimensions of cylinder volume bounds

Parameters
buBinUtility at source
cBoundsthe Cylinder volume bounds to adjust to
Returns
new updated BinUtiltiy

Definition at line 28 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 28 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, maxZ, min, and Acts::Test::minPhi.

+ Here is the call graph for this function:

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

adjust the BinUtility bu to the dimensions of radial bounds

Parameters
buBinUtility at source
rBoundsthe Radial bounds to adjust to
Returns
new updated BinUtiltiy

Definition at line 30 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 30 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::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 CylinderBounds &  cBounds 
)

adjust the BinUtility bu to the dimensions of cylinder bounds

Parameters
buBinUtility at source
cBoundsthe Cylinder bounds to adjust to
Returns
new updated BinUtiltiy

Definition at line 76 of file BinAdjustment.hpp.

View newest version in sPHENIX GitHub at line 76 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 CuboidVolumeBounds &  cBounds 
)

adjust the BinUtility bu to the dimensions of cuboid volume bounds

Parameters
buBinUtility at source
cBoundsthe Cuboid volume bounds to adjust to
Returns
new updated BinUtiltiy

Definition at line 78 of file BinAdjustmentVolume.hpp.

View newest version in sPHENIX GitHub at line 78 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, maxY, maxZ, min, and minY.

+ 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
buBinUtility at source
Surfaceto which the adjustment is being done
Returns
new updated BinUtiltiy

Definition at line 127 of file BinAdjustment.hpp.

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

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

+ 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
buBinUtility at source
Volumeto which the adjustment is being done
Returns
new updated BinUtiltiy

Definition at line 128 of file BinAdjustmentVolume.hpp.

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

References adjustBinUtility(), 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
MatrixTypeMatrix type that is produced
Parameters
bsThe bitset to convert
Returns
A matrix with the integer values of the bits from bs

Definition at line 453 of file Helpers.hpp.

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

References m.

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]detElementthe dd4hep::DetElement of the volume of which the compounds should be collected
[out]compoundsthe DD4hep::DetElements of the compounds contained by detElement

Definition at line 534 of file ConvertDD4hepDetector.cpp.

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

References 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]detElementthe dd4hep::DetElement of the volume of which the layers should be collected
[out]layersthe DD4hep::DetElements of the layers contained by detElement

Definition at line 578 of file ConvertDD4hepDetector.cpp.

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

References 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]detElementthe dd4hep::DetElement of the volume of which the sub detectors should be collected
[out]subdetectorsthe DD4hep::DetElements of the sub detectors contained by detElement

Definition at line 554 of file ConvertDD4hepDetector.cpp.

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

References 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]detElementthe dd4hep::DetElement of the volume of which the volumes should be collected
[out]volumesthe DD4hep::DetElements of the volumes contained by detElement

Definition at line 596 of file ConvertDD4hepDetector.cpp.

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

References 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:

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 MaterialProperties &  slab,
int  pdg,
float  m,
float  qOverP,
float  q = UnitConstants::e 
)

Compute the mean energy loss due to ionisation and excitation.

Parameters
slabThe traversed material and its properties
pdgParticle type PDG identifier
mParticle mass
qOverPParticle charge divided by absolute momentum
qParticle charge

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

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

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

Definition at line 135 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 135 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 MaterialProperties &  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 203 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 203 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 MaterialProperties &  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 277 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 277 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 MaterialProperties &  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 295 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 295 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 MaterialProperties &  slab,
int  pdg,
float  m,
float  qOverP,
float  q = UnitConstants::e 
)

Compute the combined mean energy loss.

Parameters
slabThe traversed material and its properties
pdgParticle type PDG identifier
mParticle mass
qOverPParticle charge divided by absolute momentum
qParticle charge

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

Definition at line 428 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 428 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 MaterialProperties &  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 440 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 440 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 MaterialProperties &  slab,
int  pdg,
float  m,
float  qOverP,
float  q = UnitConstants::e 
)

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

Parameters
slabThe traversed material and its properties
pdgParticle type PDG identifier
mParticle mass
qOverPParticle charge divided by absolute momentum
qParticle charge

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

Definition at line 372 of file Interactions.cpp.

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

References Acts::units::_GeV, ASSERT_INPUTS, eAntiMuon, eMuon, energy, 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 MaterialProperties &  slab,
int  pdg,
float  m,
float  qOverP,
float  q = UnitConstants::e 
)

Compute the core width of the projected planar scattering distribution.

Parameters
slabThe traversed material and its properties
pdgParticle type PDG identifier
mParticle mass
qOverPParticle charge divided by absolute momentum
qParticle charge

Definition at line 476 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 476 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(), 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]worldDetElementthe DD4hep DetElement of the world
[in]loggingLevelis the debug logging level of the conversion and geometry building
[in]bTypePhiis 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]bTypeRis how the sensitive surfaces (modules) should be binned in a layer in r direction
[in]bTypeZis how the sensitive surfaces (modules) should be binned in a layer in z direction
[in]layerEnvelopeRthe tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
[in]layerEnvelopeZthe tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
[in]defaultLayerThicknessIn 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]sortSubDetectorsstd::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.
matDetcroatoris the material decorator that loads material maps
Exceptions
std::logic_errorif 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 FW::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
Cellthe digitization cell
Parameters
[in]cellMapmap of all cells per cell ID on module
[in]nBins0number of bins in direction 0
[in]commonCornerflag indicating if also cells sharing a common corner should be merged into one cluster
[in]energyCutpossible 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]gridAxis1Axis data
[in]gridAxis2Axis 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]gridAxis1Axis data
[in]gridAxis2Axis data
[in]gridAxis3Axis 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]BinUtilityof the volume to be mapped
[in]Globalto 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 b, Acts::BinUtility::binningData(), binPhi, binR, binX, binY, createGrid(), globalToLocalFromBin(), and pos().

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]BinUtilityof the volume to be mapped
[in]Globalto local transform to be updated.
Returns
the 3D grid

Definition at line 162 of file MaterialGridHelper.cpp.

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

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

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
actsExtensionthe ActExtension to be checked
valueTagthe xml tag for to ActsExtension to be parsed
firstBinningstring lookup for first bin
binningthe Binning prescription for the ActsExtension

Definition at line 24 of file ConvertDD4hepMaterial.cpp.

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

References bin, binningValueNames, 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 509 of file ConvertDD4hepDetector.cpp.

View newest version in sPHENIX GitHub at line 509 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 MaterialProperties &  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 163 of file Interactions.cpp.

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

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

Referenced by deriveEnergyLossMeanQOverP().

+ Here is the caller graph for this function:

float Acts::deriveEnergyLossLandauQOverP ( const MaterialProperties &  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 226 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 226 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 MaterialProperties &  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 434 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 434 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 MaterialProperties &  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 448 of file Interactions.cpp.

View newest version in sPHENIX GitHub at line 448 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 MaterialProperties &  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 396 of file Interactions.cpp.

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

References Acts::units::_GeV, ASSERT_INPUTS, eAntiMuon, eMuon, energy, momentum, and x.

Referenced by deriveEnergyLossMeanQOverP(), and deriveEnergyLossModeQOverP().

+ Here is the caller graph for this function:

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
localToGlobalBinFunction 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]rPosValues 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]zPosValues 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]bFieldThe 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]lengthUnitThe unit of the grid points
[in]BFieldUnitThe unit of the magnetic field
[in]firstQuadrantFlag 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 22 of file BFieldMapUtils.cpp.

View newest version in sPHENIX GitHub at line 22 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(), FW::BField::txt::fieldMapperRZ(), and FW::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
localToGlobalBinFunction 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]xPosValues 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]yPosValues 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]zPosValues 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]bFieldThe 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]lengthUnitThe unit of the grid points
[in]BFieldUnitThe unit of the magnetic field
[in]firstOctantFlag 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 130 of file BFieldMapUtils.cpp.

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

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

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_DATA_TEST_CASE(), FW::BField::txt::fieldMapperXYZ(), FW::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
Cellthe digitization cell
Parameters
[in,out]mergedCellsthe final vector of cells to which cells of one cluster should be added
[in,out]cellMapthe 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]indexthe current global grid index of the cell
[in]cellAthe current cell
[in]nBins0number of bins in direction 0
[in]commonCornerflag indicating if also cells sharing a common corner should be merged into one cluster
[in]energyCutpossible 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

References int().

Referenced by createClusters().

+ Here is the call graph for this function:

+ 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]namename of the logger instance
[in]lvldebug threshold level
[in]log_streamoutput 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]namename of the logger instance
[in]lvldebug threshold level
[in]log_streamoutput 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 13 of file Logger.cpp.

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

References print().

Referenced by addCylinderLayerProtoMaterial(), addDiscLayerProtoMaterial(), Acts::Test::BOOST_AUTO_TEST_CASE(), FW::Generic::buildDetector(), FW::TGeo::buildTGeoDetector(), Acts::CuboidVolumeBuilder::buildVolume(), convertDD4hepDetector(), cylinderVolumeHelper_dd4hep(), FW::determineEventFilesRange(), AlignedDetector::finalize(), PayloadDetector::finalize(), PHActsVertexFinder::findVertices(), PHActsInitialVertexFinder::findVertices(), PHActsVertexFitter::fitVertex(), Acts::Test::LayerCreatorFixture::LayerCreatorFixture(), PHActsTrkFitter::loopTracks(), main(), FW::FittingAlgorithm::makeFitterFunction(), MakeActsGeometry::makeGeometry(), materialMappingExample(), Acts::Test::CubicTrackingGeometry::operator()(), Acts::Test::CylindricalTrackingGeometry::operator()(), processGeometry(), PHActsVertexPropagator::propagateTrack(), PHActsTrackProjection::propagateTrack(), PHTpcResiduals::propagateTrackState(), FW::Options::readFatrasConfig(), FW::Sequencer::run(), trackingGeometry(), and volumeBuilder_dd4hep().

+ Here is the call graph for this function:

+ 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]Typeof 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
Ttype of values to be interpolated
Nnumber of hyper box corners
Point1type specifying geometric positions
Point2type specifying geometric positions
Point3type specifying geometric positions
Parameters
[in]positionposition to which to interpolate
[in]lowerCornergeneralized lower-left corner of hyper box (containing the minima of the hyper box along each dimension)
[in]upperCornergeneralized upper-right corner of hyper box (containing the maxima of the hyper box along each dimension)
[in]valuesfield 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 $\text{lowerCorner}[i] \le \text{position}[i] \le \text{upperCorner}[i] \quad \forall i=0, \dots, d-1$.
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 $2^d$ where $d$ 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 77 of file Interpolation.hpp.

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

References N, 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 caller graph for this function:

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::PropagatorError  e)
inline

Definition at line 45 of file PropagatorError.hpp.

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

References 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 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 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 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 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_tWorks will all box types.
Parameters
storeOwns the created boxes by means of std::unique_ptr.
primsBoxes to store. This is a read only vector.
max_depthNo subdivisions beyond this level.
envelope1Envelope 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.

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

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

References epsilon(), norm, and scale.

Referenced by makeCurvilinearUnitVectors(), and ActsFatras::detail::Scattering< scattering_model_t >::operator()().

+ Here is the call graph for this function:

+ 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
directionis 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 109 of file UnitVectors.hpp.

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

References makeCurvilinearUnitU().

+ Here is the call 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
phiis the direction angle in the x-y plane.
etais 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

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_DATA_TEST_CASE(), and FW::ParametricProcessGenerator::operator()().

+ 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
phiis the direction angle in radian in the x-y plane.
thetais 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 49 of file UnitVectors.hpp.

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

Referenced by BOOST_AUTO_TEST_CASE().

+ Here is the caller graph for this function:

Acts::MaterialGrid2D Acts::mapMaterialPoints ( Acts::Grid2D grid,
const Acts::RecordedMaterialPoint 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]gridThe material collecting grid
[in]mPointsThe set of material at the space points
[in]transfoGlobalToLocaltranformation from local to local coordinate
Returns
The average material grid decomposed into classification numbers

Definition at line 213 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 213 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::RecordedMaterialPoint 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]gridThe material collecting grid
[in]mPointsThe set of material at the space points
[in]transfoGlobalToLocaltranformation from local to local coordinate
Returns
The average material grid decomposed into classification numbers

Definition at line 242 of file MaterialGridHelper.cpp.

View newest version in sPHENIX GitHub at line 242 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]materialVectorToGridMapperFunction 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]rPosValues 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]zPosValues 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]materialThe 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]lengthUnitThe unit of the grid points

Definition at line 19 of file MaterialMapUtils.cpp.

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

References mat, 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]materialVectorToGridMapperFunction 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]xPosValues 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]yPosValues 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]zPosValues 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]materialThe 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]lengthUnitThe unit of the grid points

Definition at line 101 of file MaterialMapUtils.cpp.

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

References k, mat, 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
DerivedEigen base concrete type
Parameters
mMatrix that is converted
Returns
The converted bitset.

Definition at line 477 of file Helpers.hpp.

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

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

+ Here is the caller graph for this function:

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

Definition at line 90 of file SurfaceBounds.hpp.

View newest version in sPHENIX GitHub at line 90 of file SurfaceBounds.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(), and pdg.

+ Here is the call graph for this function:

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

Definition at line 53 of file MeasurementHelpers.hpp.

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

References Acts::MinimalSourceLink::meas.

std::ostream& Acts::operator<< ( std::ostream &  os,
BoundarySurfaceFace &  face 
)
inline

Definition at line 66 of file BoundarySurfaceFace.hpp.

View newest version in sPHENIX GitHub at line 66 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
osThe out stream
rayThe 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 73 of file GlueVolumesDescriptor.cpp.

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

References Acts::GlueVolumesDescriptor::screenOutput().

+ Here is the call graph for this function:

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 &  os,
const MaterialProperties &  materialProperties 
)

Definition at line 80 of file MaterialProperties.cpp.

View newest version in sPHENIX GitHub at line 80 of file MaterialProperties.cpp

References Acts::MaterialProperties::material(), and Acts::MaterialProperties::thickness().

+ Here is the call graph for this function:

std::ostream& Acts::operator<< ( std::ostream &  os,
const SurfaceBounds &  sb 
)
inline

Definition at line 94 of file SurfaceBounds.hpp.

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

References Acts::SurfaceBounds::toStream().

+ Here is the call graph for this function:

std::ostream & Acts::operator<< ( std::ostream &  os,
const Material &  material 
)

Definition at line 62 of file Material.cpp.

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

References Acts::Material::Ar(), Acts::Material::L0(), Acts::Material::massDensity(), Acts::Material::X0(), and Acts::Material::Z().

+ Here is the call graph for this function:

std::ostream & Acts::operator<< ( std::ostream &  os,
GeometryID  id 
)

Definition at line 14 of file GeometryID.cpp.

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

std::ostream& Acts::operator<< ( std::ostream &  os,
const IVisualization &  hlp 
)
inline

Overload of the << operator to facilitate writing to streams.

Parameters
osThe output stream
hlpThe helper instance

Definition at line 124 of file IVisualization.hpp.

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

References Acts::IVisualization::write().

+ 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 16 of file VolumeBounds.cpp.

View newest version in sPHENIX GitHub at line 16 of file VolumeBounds.cpp

References Acts::VolumeBounds::toStream().

+ 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 96 of file Volume.cpp.

View newest version in sPHENIX GitHub at line 96 of file Volume.cpp

References Acts::Volume::volumeBounds().

+ 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
Tentity type
Uvalue type
Vdimension
Parameters
osThe output stream
boxThe 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

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 20 of file BinUtility.cpp.

View newest version in sPHENIX GitHub at line 20 of file BinUtility.cpp

References Acts::BinUtility::toStream().

+ Here is the call graph for this function:

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

Definition at line 83 of file SurfaceBounds.hpp.

View newest version in sPHENIX GitHub at line 83 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 133 of file VolumeBounds.hpp.

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

Definition at line 40 of file PropagatorError.hpp.

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

References c.

static const RotationMatrix3D Acts::s_idRotationZinverse ( detail::_helper  )
static
static const Vector3D Acts::s_origin ( ,
,
 
)
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 ( ,
,
 
)
static

global x Axis;

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

global y Axis;

static const Vector3D Acts::s_zAxis ( ,
,
 
)
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
rlimpair of r bounds
zlimpair of z bounds
nbinspair of bin counts
fieldthe solenoid field instance
Returns
A field mapper instance for use in interpolation.

Definition at line 250 of file BFieldMapUtils.cpp.

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

References kdfinder::abs(), B(), 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

References a, and b.

template<typename propagator_state_t >
void Acts::targetDebugLog ( propagator_state_t &  state,
const std::string &  status,
const std::function< std::string()> &  logAction 
)

The debug logging for standard aborters

It needs to be fed by a lambda function that returns a string, that guarantees that the lambda is only called in the state.options.debug == true case in order not to spend time when not needed.

Parameters
statethe propagator cache for the debug flag, prefix/stream
logActionis a callable function that returns a streamable object

Definition at line 50 of file StandardAborters.hpp.

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

Referenced by Acts::PathLimitReached::operator()(), and Acts::SurfaceReached::operator()().

+ Here is the caller graph for this function:

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
CallableType which takes a size_t as a compile time param
NValue from which to start the dispatch chain, i.e. 0 in most cases
NMAXMaximum value up to which to attempt a dispatch
Parameters
vThe runtime value to dispatch on
argsAdditional arguments passed to Callable::invoke().
Note
Callable is expected to have a static member function invoke that is callable with Args

Definition at line 431 of file Helpers.hpp.

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

References N, NMAX, and v.

Referenced by visit_measurement().

+ Here is the caller graph for this function:

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

Print out a matrix in a structured way.

Parameters
matrixThe matrix to print
precisionNumeric output precision
offsetOffset in front of matrix lines
Returns
The printed string

Definition at line 312 of file Helpers.hpp.

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

References 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
matrixThe translation to print
precisionNumeric output precision
Returns
The printed string

Definition at line 355 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 355 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
matrixThe transform to print
precisionNumeric output precision
offsetOffset in front of matrix lines
Returns
The printed string

Definition at line 369 of file Helpers.hpp.

View newest version in sPHENIX GitHub at line 369 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 Acts::units::_mm, 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(), FW::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
Tthe stored type
Parameters
itemsThe vector of shared_ptr
Returns
The unpacked vector

Definition at line 386 of file Helpers.hpp.

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

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), Acts::Test::BOOST_FIXTURE_TEST_CASE(), Acts::GenericApproachDescriptor::GenericApproachDescriptor(), Acts::ProtoLayer::ProtoLayer(), 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
Tthe stored type
Parameters
itemsThe vector of shared_ptr
Returns
The unpacked vector

Definition at line 402 of file Helpers.hpp.

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

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
LThe lambda type
AThe parameter vector type
BThe 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
paramThe parameter vector
covThe covariance matrix
dimThe actual dimension as a runtime value
lambdaThe lambda to call with the statically sized subsets

Definition at line 99 of file MeasurementHelpers.hpp.

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

References Acts::Test::dim, eBoundParametersSize, G4InuclParticleNames::lambda, and template_switch().

Referenced by Acts::Test::BOOST_AUTO_TEST_CASE(), and Acts::GainMatrixUpdater< parameters_t >::operator()().

+ Here is the call graph for this function:

+ 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]worldDetElementthe DD4hep DetElement of the world
[in]loggingLevelis the debug logging level of the conversion and geometry building
[in]bTypePhiis 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]bTypeRis how the sensitive surfaces (modules) should be binned in a layer in r direction
[in]bTypeZis how the sensitive surfaces (modules) should be binned in a layer in z direction
[in]layerEnvelopeRthe tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
[in]layerEnvelopeZthe tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
[in]defaultLayerThicknessIn 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(), 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::volumeMaterial, 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_materialthe material tag to be inspected
actsExtensionthe extension that is augmented
baseTagthe xml tag to be checked

Definition at line 101 of file ConvertDD4hepMaterial.cpp.

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

References Acts::ActsExtension::addType(), Acts::ActsExtension::addValue(), bin, 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(), G4DisplacedSolid::GetDirectTransform(), G4ReflectedSolid::GetDirectTransform3D(), and G4DisplacedSolid::GetTransform().

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

template<typename fitter >
constexpr bool Acts::LinearizerConcept
Initial value:

Definition at line 51 of file LinearizerConcept.hpp.

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

template<typename parameters_t >
constexpr bool Acts::ParameterConcept
Initial value:

Definition at line 122 of file ParameterConcept.hpp.

View newest version in sPHENIX GitHub at line 122 of file ParameterConcept.hpp

constexpr int Acts::PolygonDynamic = -1

Tag to trigger specialization of a dynamic polygon.

Definition at line 136 of file ConvexPolygonBounds.hpp.

View newest version in sPHENIX GitHub at line 136 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::BOOST_AUTO_TEST_CASE(), Acts::CylinderVolumeBounds::buildSurfaceBounds(), Acts::ConeBounds::checkConsistency(), Acts::AnnulusBounds::checkConsistency(), and Acts::PlaneSurface::polyhedronRepresentation().

const Rotation3D Acts::s_idRotation
static
Initial value:
=
Rotation3D::Identity()

idendity rotation

Definition at line 24 of file GeometryStatics.hpp.

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

Referenced by Acts::TrapezoidVolumeBounds::decomposeToSurfaces().

const Transform3D Acts::s_idTransform
static
Initial value:
=
Transform3D::Identity()

idendity transformation

Definition at line 22 of file GeometryStatics.hpp.

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

Referenced by Acts::LayerArrayCreator::createNavigationSurface(), Acts::Volume::transform(), and Acts::Surface::transform().

const InfiniteBounds Acts::s_noBounds {}
static

Definition at line 56 of file InfiniteBounds.hpp.

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

Referenced by Acts::SurfaceStub::bounds(), Acts::PlaneSurface::bounds(), and Acts::LineSurface::bounds().

template<typename T >
constexpr bool Acts::SourceLinkConcept
Initial value:

Definition at line 58 of file SourceLinkConcept.hpp.

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

template<typename stepper , typename state = typename stepper::State>
constexpr bool Acts::StepperConcept
Initial value:

Definition at line 152 of file StepperConcept.hpp.

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

template<typename stepper >
constexpr bool Acts::StepperStateConcept
Initial value:
=
Acts::concept ::Stepper::StepperStateConcept<stepper>

Definition at line 155 of file StepperConcept.hpp.

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

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:

Definition at line 40 of file VertexFinderConcept.hpp.

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

template<typename fitter >
constexpr bool Acts::VertexFitterConcept
Initial value:

Definition at line 58 of file VertexFitterConcept.hpp.

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