Namespace Acts¶
-
namespace Acts
Note
This file is foreseen for the
Geometry
module to replaceExtent
Typedefs
-
using ActsDynamicMatrix = Eigen::Matrix<ActsScalar, Eigen::Dynamic, Eigen::Dynamic>
-
using ActsDynamicVector = Eigen::Matrix<ActsScalar, Eigen::Dynamic, 1>
-
using ActsMatrix = Eigen::Matrix<ActsScalar, kRows, kCols>
-
using ActsScalar = double
Common scalar (floating point type used for the default algebra types.
Defaults to
double
but can be customized by the user.
-
using ActsSymMatrix = Eigen::Matrix<ActsScalar, kSize, kSize>
-
using ActsVector = Eigen::Matrix<ActsScalar, kSize, 1>
-
using AlignmentMatrix = ActsMatrix<eAlignmentSize, eAlignmentSize>
-
using AlignmentRowVector = ActsMatrix<1, eAlignmentSize>
-
using AlignmentToBoundMatrix = ActsMatrix<eBoundSize, eAlignmentSize>
-
using AlignmentToPathMatrix = ActsMatrix<1, eAlignmentSize>
-
using AlignmentToPositionMatrix = ActsMatrix<3, eAlignmentSize>
-
using AlignmentVector = ActsVector<eAlignmentSize>
-
using AngleAxis3 = Eigen::AngleAxis<ActsScalar>
-
using AxisScalar = Vector3::Scalar
-
using BoundaryIntersection = ObjectIntersection<BoundarySurface, Surface>
Intersection with a
BoundarySurface
.
-
using BoundarySurface = BoundarySurfaceT<TrackingVolume>
BoundarySurface of a volume.
-
using BoundarySurfacePtr = std::shared_ptr<const BoundarySurfaceT<AbstractVolume>>
-
using BoundMatrix = ActsMatrix<eBoundSize, eBoundSize>
-
using BoundSymMatrix = ActsSymMatrix<eBoundSize>
-
using BoundToFreeMatrix = ActsMatrix<eFreeSize, eBoundSize>
-
using BoundTrackParameters = SingleBoundTrackParameters<SinglyCharged>
-
using BoundVariantMeasurement = VariantMeasurement<BoundIndices>
Variant that can hold all possible bound measurements.
-
using BoundVector = ActsVector<eBoundSize>
-
using CalibrationContext = 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
-
using ColorRGB = std::array<int, 3>
The color typedef.
It’s an array of three numbers [0, 255] representing the RGB color values.
-
using CurvilinearTrackParameters = SingleCurvilinearTrackParameters<SinglyCharged>
-
using DefaultExtension = detail::GenericDefaultExtension<double>
A typedef for the default GenericDefaultExtension with double.
-
using DenseEnvironmentExtension = detail::GenericDenseEnvironmentExtension<double>
A typedef for the default GenericDenseEnvironmentExtension with double.
-
using EAxis = Acts::detail::EquidistantAxis
-
using Envelope = std::array<ActsScalar, 2>
-
using ExtentEnvelope = std::array<std::array<ActsScalar, 2>, binValues>
-
using FreeMatrix = ActsMatrix<eFreeSize, eFreeSize>
-
using FreeSymMatrix = ActsSymMatrix<eFreeSize>
-
using FreeToBoundMatrix = ActsMatrix<eBoundSize, eFreeSize>
-
using FreeToPathMatrix = ActsMatrix<1, eFreeSize>
-
using FreeTrackParameters = SingleFreeTrackParameters<SinglyCharged>
-
using FreeVariantMeasurement = VariantMeasurement<FreeIndices>
Variant that can hold all possible free measurements.
-
using FreeVector = ActsVector<eFreeSize>
-
using GeometryContext = ContextType
This is the central definition of the Acts payload object regarding detector geometry status (e.g.
alignment)
It is propagated through the code to allow for event/thread dependent geometry changes
-
using GeometryIdentifierHook = std::function<GeometryIdentifier(GeometryIdentifier, const Surface&)>
-
using Grid2D = Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis>
-
using HashedString = std::uint32_t
-
using Intersection2D = Intersection<2>
-
using Intersection3D = Intersection<3>
-
typedef BinnedArray<LayerPtr> LayerArray
A BinnedArray to a std::shared_ptr of a layer.
Layers are constructedd with shared_ptr factories, hence the layer array is describes as:
-
using LayerIntersection = ObjectIntersection<Layer, Surface>
-
typedef std::shared_ptr<const Layer> LayerPtr
A std::shared_ptr to a Layer.
-
typedef std::vector<LayerPtr> LayerVector
A vector of std::shared_ptr to layers.
-
using MagneticFieldContext = ContextType
This is the central definition of the Acts payload object regarding magnetic field status.
It is propagated through the code to allow for event/thread dependent magnetic field changes
-
using MaterialSlabMatrix = std::vector<MaterialSlabVector>
-
using MaterialSlabVector = std::vector<MaterialSlab>
-
typedef std::shared_ptr<Layer> MutableLayerPtr
-
typedef std::shared_ptr<TrackingVolume> MutableTrackingVolumePtr
-
typedef std::vector<MutableTrackingVolumePtr> MutableTrackingVolumeVector
-
using NeighborhoodVector = boost::container::small_vector<size_t, 10>
-
using NeutralBoundTrackParameters = SingleBoundTrackParameters<Neutral>
-
using NeutralCurvilinearTrackParameters = SingleCurvilinearTrackParameters<Neutral>
-
using NeutralFreeTrackParameters = SingleFreeTrackParameters<Neutral>
-
using OrientedSurface = std::pair<SurfacePtr, NavigationDirection>
-
using OrientedSurfaces = std::vector<OrientedSurface>
-
using ProjectorBitset = std::bitset<eBoundSize * eBoundSize>
-
using Ray3D = Ray<ActsScalar, 3>
-
using RecordedMaterialTrack = std::pair<std::pair<Acts::Vector3, Acts::Vector3>, RecordedMaterial>
And recorded material track.
this is start: position, start momentum and the Recorded material
-
using RecordedMaterialVolumePoint = std::vector<std::pair<Acts::MaterialSlab, std::vector<Acts::Vector3>>>
list of point used in the mapping of a volume
-
using RotationMatrix2 = ActsMatrix<2, 2>
-
using RotationMatrix3 = ActsMatrix<3, 3>
-
using SourceLinkAccessorDelegate = Delegate<std::pair<source_link_iterator_t, source_link_iterator_t>(const Surface&)>
Delegate type that retrieves a range of source links to for a given surface to be processed by the CKF.
-
using SpacePointGrid = detail::Grid<std::vector<std::unique_ptr<InternalSpacePoint<external_spacepoint_t>>>, detail::Axis<detail::AxisType::Equidistant, detail::AxisBoundaryType::Closed>, detail::Axis<detail::AxisType::Variable, detail::AxisBoundaryType::Bound>>
-
typedef std::tuple<std::shared_ptr<const Acts::Surface>, std::shared_ptr<const Acts::ISurfaceMaterial>, Acts::GeometryContext> SurfaceAndMaterialWithContext
-
typedef ObjectIntersection<Surface> SurfaceIntersection
Typedef of the surface intersection.
-
using SurfaceMatcher = std::function<bool(const GeometryContext &gctx, BinningValue, const Surface*, const Surface*)>
-
using surfaceMaterialPointer = const Acts::ISurfaceMaterial*
-
using SurfaceMatrix = std::vector<SurfaceVector>
-
typedef std::shared_ptr<const Surface> SurfacePtr
-
typedef std::vector<SurfacePtr> SurfacePtrVector
-
typedef std::vector<const Surface*> SurfaceVector
-
using SymMatrix2 = ActsSymMatrix<2>
-
using SymMatrix3 = ActsSymMatrix<3>
-
using SymMatrix4 = ActsSymMatrix<4>
-
typedef std::pair<const Acts::TrackingVolume*, std::shared_ptr<const Acts::IVolumeMaterial>> TrackingVolumeAndMaterial
-
typedef BinnedArray<TrackingVolumePtr> TrackingVolumeArray
A BinnedArray of a std::shared_tr to a TrackingVolume.
-
using TrackingVolumeBoundaries = std::vector<TrackingVolumeBoundaryPtr>
-
using TrackingVolumeBoundaryPtr = std::shared_ptr<const BoundarySurfaceT<TrackingVolume>>
-
using TrackingVolumeOrderPosition = std::pair<TrackingVolumePtr, Vector3>
-
using TrackingVolumePointer = const Acts::TrackingVolume*
-
typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr
A std::shared_ptr to a tracking volume.
-
typedef std::vector<TrackingVolumePtr> TrackingVolumeVector
A std::vector of a std::shared_ptr to a TrackingVolume.
-
using TrackStateType = std::bitset<TrackStateFlag::NumTrackStateFlags>
-
using Transform2 = Eigen::Transform<ActsScalar, 2, Eigen::AffineCompact>
-
using Transform3 = Eigen::Transform<ActsScalar, 3, Eigen::Affine>
-
using Translation2 = Eigen::Translation<ActsScalar, 2>
-
using Translation3 = Eigen::Translation<ActsScalar, 3>
-
using V3Matrix = std::vector<V3Vector>
-
using V3Vector = std::vector<Vector3>
-
using VariantCovariance = std::variant<BoundSymMatrix, FreeSymMatrix>
-
using VariantMeasurement = typename detail::VariantMeasurementGenerator<indices_t, detail::kParametersSize<indices_t>>::Type
Variant that can contain all possible measurements in a parameter space.
- Template Parameters
indices_t – Parameter index type, determines the full parameter space
-
using VariantTransportJacobian = std::variant<BoundMatrix, BoundToFreeMatrix, FreeToBoundMatrix, FreeMatrix>
-
using Vector2 = ActsVector<2>
-
using Vector3 = ActsVector<3>
-
using Vector4 = ActsVector<4>
-
typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr
-
using volumeMaterialPointer = const Acts::IVolumeMaterial*
Enums
-
enum AlignmentIndices
Components of alignment parameters vector.
To be used to access components by named indices instead of just numbers. This must be a regular
enum
and not a scopedenum class
to allow implicit conversion to an integer. The enum value are thus visible directly innamespace Acts
and are prefixed to avoid naming collisions.Values:
-
enumerator eAlignmentCenter0
-
enumerator eAlignmentCenter1
-
enumerator eAlignmentCenter2
-
enumerator eAlignmentRotation0
-
enumerator eAlignmentRotation1
-
enumerator eAlignmentRotation2
-
enumerator eAlignmentSize
-
enumerator eAlignmentCenter0
-
enum BinningOption
flag for open/closed bins
Values:
-
enumerator open
-
enumerator closed
-
enumerator open
-
enum BinningType
, BinningOption & BinningAccess
BinningType:
Enumeration to qualify the binning type for the use of the LayerArrayCreator and the TrackingVolumeArrayCreator
BinningOption: open: [0,max] closed: 0 -> nextbin -> max -> 0
BinningValue necessary access to global positions
Values:
-
enumerator equidistant
-
enumerator arbitrary
-
enum BinningValue
how to take the global / local position
Values:
-
enumerator binX
-
enumerator binY
-
enumerator binZ
-
enumerator binR
-
enumerator binPhi
-
enumerator binRPhi
-
enumerator binH
-
enumerator binEta
-
enumerator binMag
-
enumerator binValues
-
enumerator binX
-
enum BoundarySurfaceFace
Enum to describe the position of the BoundarySurface respectively to the frame orientatin of the volume, this is mainly ment for code readability.
The different numeration sequences can be found in the documentation of the actual VolumeBounds implementations.
The order of faces is chosen to follow - as much as possible - a cycular structure.
Values:
-
enumerator negativeFaceXY
-
enumerator positiveFaceXY
-
enumerator negativeFaceYZ
-
enumerator positiveFaceYZ
-
enumerator negativeFaceZX
-
enumerator positiveFaceZX
-
enumerator cylinderCover
-
enumerator tubeInnerCover
-
enumerator tubeOuterCover
-
enumerator tubeSectorNegativePhi
-
enumerator tubeSectorPositivePhi
-
enumerator tubeSectorInnerCover
-
enumerator tubeSectorOuterCover
-
enumerator trapezoidFaceAlpha
-
enumerator trapezoidFaceBeta
-
enumerator index0
-
enumerator index1
-
enumerator index2
-
enumerator index3
-
enumerator index4
-
enumerator index5
-
enumerator index6
-
enumerator index7
-
enumerator index8
-
enumerator index9
-
enumerator index10
-
enumerator index11
-
enumerator undefinedFace
-
enumerator negativeFaceXY
-
enum BoundIndices
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 scopedenum class
to allow implicit conversion to an integer. The enum value are thus visible directly innamespace Acts
and are prefixed to avoid naming collisions.Values:
-
enumerator eBoundLoc0
-
enumerator eBoundLoc1
-
enumerator eBoundPhi
-
enumerator eBoundTheta
-
enumerator eBoundQOverP
-
enumerator eBoundTime
-
enumerator eBoundSize
-
enumerator eBoundLoc0
-
enum CombinatorialKalmanFilterError
Values:
-
enumerator UpdateFailed
-
enumerator SmoothFailed
-
enumerator OutputConversionFailed
-
enumerator MeasurementSelectionFailed
-
enumerator NoTrackFound
-
enumerator PropagationReachesMaxSteps
-
enumerator UpdateFailed
-
enum CoordinateIndices
Components of coordinate vectors.
To be used to access coordinate components by named indices instead of magic numbers. This must be a regular
enum
and not a scopedenum class
to allow implicit conversion to an integer. The enum value are thus visible directly innamespace Acts
.This index enum is not user-configurable (in contrast e.g. to the track parameter index enums) since it must be compatible with varying dimensionality (2d-4d) and other access methods (
.{x,y,z}()
accessors).Values:
-
enumerator ePos0
-
enumerator ePos1
-
enumerator ePos2
-
enumerator eTime
-
enumerator eMom0
-
enumerator eMom1
-
enumerator eMom2
-
enumerator eEnergy
-
enumerator eX
-
enumerator eY
-
enumerator eZ
-
enumerator ePos0
-
enum EigenStepperError
Values:
-
enumerator StepSizeStalled
-
enumerator StepInvalid
-
enumerator StepSizeAdjustmentFailed
-
enumerator StepSizeStalled
-
enum FreeIndices
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 scopedenum class
to allow implicit conversion to an integer. The enum value are thus visible directly innamespace Acts
and are prefixed to avoid naming collisions.Values:
-
enumerator eFreePos0
-
enumerator eFreePos1
-
enumerator eFreePos2
-
enumerator eFreeTime
-
enumerator eFreeDir0
-
enumerator eFreeDir1
-
enumerator eFreeDir2
-
enumerator eFreeQOverP
-
enumerator eFreeSize
-
enumerator eFreePos0
-
enum GsfError
Values:
-
enumerator ComponentNumberMismatch
-
enumerator AllComponentsSteppingError
-
enumerator NoComponentCreated
-
enumerator NoStatesCreated
-
enumerator StartParametersNotOnStartSurface
-
enumerator PropagationEndedOnWrongSurface
-
enumerator LastStepParamsContainNan
-
enumerator SmoothingFailed
-
enumerator ComponentNumberMismatch
-
enum IntersectionStatus
Status enum.
Values:
-
enumerator missed
-
enumerator unreachable
-
enumerator reachable
-
enumerator onSurface
-
enumerator missed
-
enum KalmanFitterError
Values:
-
enumerator ForwardUpdateFailed
-
enumerator BackwardUpdateFailed
-
enumerator SmoothFailed
-
enumerator OutputConversionFailed
-
enumerator NoMeasurementFound
-
enumerator ForwardUpdateFailed
-
enum LayerType
For code readability, it distinguishes between different type of layers, which steers the behaviour in the navigation.
Values:
-
enumerator passive
-
enumerator active
-
enumerator passive
-
enum MagneticFieldError
Values:
-
enumerator OutOfBounds
-
enumerator OutOfBounds
-
enum MappingType
This enum describes the type of surface material mapping.
Values:
-
enumerator PreMapping
-
enumerator Default
-
enumerator PostMapping
-
enumerator Sensor
-
enumerator PreMapping
-
enum MaterialUpdateStage
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
Values:
-
enumerator PreUpdate
-
enumerator FullUpdate
-
enumerator PostUpdate
-
enum MultiStepperError
Values:
-
enumerator ComponentNotOnSurface
-
enumerator StateOfMultipleComponentsRequested
-
enumerator AverageTrackLeftCurrentVolume
-
enumerator AllComponentsSteppingError
-
enumerator AllComponentsConversionToBoundFailed
-
enumerator SomeComponentsConversionToBoundFailed
-
enumerator ComponentNotOnSurface
The navigation direction is always with respect to a given momentum or direction.
Values:
-
enum NoiseUpdateMode
to tell how to deal with noise term in covariance transport
removeNoise: subtract noise term
addNoise: add noise term
Values:
-
enumerator removeNoise
-
enumerator addNoise
-
enum PdgParticle
Symbolic values for commonly used PDG particle numbers.
Values:
-
enumerator eInvalid
-
enumerator eElectron
-
enumerator eAntiElectron
-
enumerator ePositron
-
enumerator eMuon
-
enumerator eAntiMuon
-
enumerator eTau
-
enumerator eAntiTau
-
enumerator eGamma
-
enumerator ePionZero
-
enumerator ePionPlus
-
enumerator ePionMinus
-
enumerator eNeutron
-
enumerator eAntiNeutron
-
enumerator eProton
-
enumerator eAntiProton
-
enumerator eInvalid
-
enum PropagatorError
Values:
-
enumerator Failure
-
enumerator WrongDirection
-
enumerator StepCountLimitReached
-
enumerator Failure
-
enum SurfaceError
Values:
-
enumerator GlobalPositionNotOnSurface
-
enumerator GlobalPositionNotOnSurface
-
enum TrackStateFlag
This enum describes the type of TrackState.
Values:
-
enumerator MeasurementFlag
-
enumerator ParameterFlag
-
enumerator OutlierFlag
-
enumerator HoleFlag
-
enumerator MaterialFlag
-
enumerator NumTrackStateFlags
-
enumerator MeasurementFlag
-
enum TrackStatePropMask
Collection of bit masks to enable steering which components of a track state should be initialized, and which should be left invalid.
These mask values can be combined using binary operators, so (TrackStatePropMask::Predicted | TrackStatePropMask::Jacobian) will instruct allocating storage for both predicted parameters (including covariance) and a jacobian. The enum is used as a strong type wrapper around the bits to prevent autoconversion from integer
Values:
-
enumerator None
-
enumerator Predicted
-
enumerator Filtered
-
enumerator Smoothed
-
enumerator Jacobian
-
enumerator Calibrated
-
enumerator All
-
enumerator None
-
enum VertexingError
Values:
-
enumerator NumericFailure
-
enumerator EmptyInput
-
enumerator SeedingError
-
enumerator NotConverged
-
enumerator ElementNotFound
-
enumerator NoCovariance
-
enumerator NumericFailure
-
enum WrappingCondition
Values:
-
enumerator Undefined
inconsistency detected
-
enumerator Attaching
attach the volumes
-
enumerator Inserting
insert the new volume
-
enumerator Wrapping
wrap the new volume around
-
enumerator CentralInserting
insert the new one into the center
-
enumerator CentralWrapping
wrap the new central volume around
-
enumerator NoWrapping
no inner volume present - no wrapping needed
-
enumerator Undefined
Functions
-
void addCylinderLayerProtoMaterial(dd4hep::DetElement detElement, Layer &cylinderLayer, LoggerWrapper logger = getDummyLogger())
Helper method to translate DD4hep material to Acts::ISurfaceMaterial.
This is used to assign proto material to Cylinder Layers
- Parameters
detElement – the DD4hep detector element for which this material is assigned
cylinderLayer – is the target layer
logger – a
LoggerWrapper
for output
-
void addDiscLayerProtoMaterial(dd4hep::DetElement detElement, Layer &discLayer, LoggerWrapper logger = getDummyLogger())
Helper method to translate DD4hep material to Acts::ISurfaceMaterial.
Thisis used to assign proto material to Disc Layers
- Parameters
detElement – the DD4hep detector element for which this material is assigned
discLayer – is the target layer
logger – a
LoggerWrapper
for output
-
void addLayerProtoMaterial(const dd4hep::rec::VariantParameters ¶ms, Layer &layer, const std::vector<std::pair<const std::string, Acts::BinningOption>> &binning, LoggerWrapper logger = getDummyLogger())
Helper method to be called for Cylinder and Disc Proto material.
For both, cylinder and disc, the closed binning value is “binPhi”
- Parameters
params – An instance of
DD4hep::VariantParameters
layer – the Layer to assign the proto material
binning – the Binning prescription for the ActsExtension
logger – a
LoggerWrapper
for output
-
BinUtility adjustBinUtility(const BinUtility &bu, const CylinderVolumeBounds &cBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of cylinder volume bounds
- Parameters
bu – BinUtility at source
cBounds – the Cylinder volume bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const RadialBounds &rBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of radial bounds
- Parameters
bu – BinUtility at source
rBounds – the Radial bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const CylinderBounds &cBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of cylinder bounds
- Parameters
bu – BinUtility at source
cBounds – the Cylinder bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const CutoutCylinderVolumeBounds &cBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of cutout cylinder volume bounds
- Parameters
bu – BinUtility at source
cBounds – the Cutout Cylinder volume bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const RectangleBounds &pBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of plane bounds
- Parameters
bu – BinUtility at source
pBounds – the Rectangle bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const CuboidVolumeBounds &cBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of cuboid volume bounds
- Parameters
bu – BinUtility at source
cBounds – the Cuboid volume bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const TrapezoidBounds &pBounds, const Transform3 &transform)
adjust the BinUtility bu to the dimensions of plane bounds
- Parameters
bu – BinUtility at source
pBounds – the Trapezoid bounds to adjust to
transform – Transform for the adjusted
BinUtility
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const Volume &volume)
adjust the BinUtility bu to a volume
- Parameters
bu – BinUtility at source
volume – Volume to which the adjustment is being done
- Returns
new updated BinUtiltiy
-
BinUtility adjustBinUtility(const BinUtility &bu, const Surface &surface, const GeometryContext &gctx)
adjust the BinUtility bu to a surface
- Parameters
bu – BinUtility at source
surface – Surface to which the adjustment is being done
gctx – Geometry context to get the surfaces transform
- Returns
new updated BinUtiltiy
-
inline const std::vector<std::string> &binningValueNames()
screen output option
-
template<typename MatrixType>
MatrixType bitsetToMatrix(const std::bitset<MatrixType::RowsAtCompileTime * MatrixType::ColsAtCompileTime> bs) Convert a bitset to a matrix of integers, with each element set to the bit value.
Note
How the bits are assigned to matrix elements depends on the storage type of the matrix being converted (row-major or col-major)
- Template Parameters
MatrixType – Matrix type that is produced
- Parameters
bs – The bitset to convert
- Returns
A matrix with the integer values of the bits from
bs
-
template<typename A, typename B>
inline ActsMatrix<A::RowsAtCompileTime, B::ColsAtCompileTime> blockedMult(const A &a, const B &b) Perform a blocked matrix multiplication, avoiding Eigen GEMM methods.
- Template Parameters
A – The type of the first matrix, which should be MxN
B – The type of the second matrix, which should be NxP
- Parameters
a – [in] An MxN matrix of type A
b – [in] An NxP matrix of type P
- Returns
The product ab
-
void collectCompounds_dd4hep(dd4hep::DetElement &detElement, std::vector<dd4hep::DetElement> &compounds)
Method internally used by convertDD4hepDetector to collect all volumes of a compound detector.
- Parameters
detElement – [in] the dd4hep::DetElement of the volume of which the compounds should be collected
compounds – [out] the DD4hep::DetElements of the compounds contained by detElement
-
void collectLayers_dd4hep(dd4hep::DetElement &detElement, std::vector<dd4hep::DetElement> &layers, LoggerWrapper logger)
Method internally used by convertDD4hepDetector.
- Parameters
detElement – [in] the dd4hep::DetElement of the volume of which the layers should be collected
layers – [out] the DD4hep::DetElements of the layers contained by detElement
logger – a
LoggerWrapper
for output
-
void collectSubDetectors_dd4hep(dd4hep::DetElement &detElement, std::vector<dd4hep::DetElement> &subdetectors, LoggerWrapper logger)
Method internally used by convertDD4hepDetector to collect all sub detectors Sub detector means each ‘compound’ DetElement or DetElements which are declared as ‘isBarrel’ or ‘isBeampipe’ by their extension.
- Parameters
detElement – [in] the dd4hep::DetElement of the volume of which the sub detectors should be collected
subdetectors – [out] the DD4hep::DetElements of the sub detectors contained by detElement
logger – a
LoggerWrapper
for output
-
float computeEnergyLossBethe(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the mean energy loss due to ionisation and excitation.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeEnergyLossLandau(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the most propable energy loss due to ionisation and excitation.
Compute the mean energy loss due to ionisation and excitation.
This computes the mean energy loss -dE(x) through a material with the given properties, i.e. it computes
-dE(x) = -dE/dx * x
where -dE/dx is given by the Bethe formula. The computations are valid for intermediate particle energies.
This computes the most probable energy loss -dE(x) through a material of the given properties and thickness as described by the mode of the Landau-Vavilov-Bichsel distribution. The computations are valid for intermediate particle energies.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeEnergyLossLandauSigma(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the Gaussian-equivalent sigma for the ionisation loss fluctuations.
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.
See also
computeEnergyLossBethe for parameters description
-
float computeEnergyLossLandauSigmaQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute q/p Gaussian-equivalent sigma due to ionisation loss fluctuations.
Compute the mean energy loss due to ionisation and excitation.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeEnergyLossMean(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the combined mean energy loss.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeEnergyLossMode(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the combined most probably energy loss.
Compute the combined mean energy loss.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeEnergyLossRadiative(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the mean energy loss due to radiative effects at high energies.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float computeMultipleScatteringTheta0(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Compute the core width of the projected planar scattering distribution.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
Global method which creates the TrackingGeometry from DD4hep input.
This method returns a std::unique_ptr of the TrackingGeometry from the World DD4hep DetElement.
- Attention
The default thickness should be set thin enough that no touching or overlapping with the next layer can happen.
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
Note
equidistant binningtype is recommended because it is faster not only while building the geometry but also for look up during the extrapolation
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.
- Parameters
worldDetElement – [in] the DD4hep DetElement of the world
loggingLevel – [in] is the debug logging level of the conversion and geometry building
bTypePhi – [in] is how the sensitive surfaces (modules) should be binned in a layer in phi direction.
bTypeR – [in] is how the sensitive surfaces (modules) should be binned in a layer in r direction
bTypeZ – [in] is how the sensitive surfaces (modules) should be binned in a layer in z direction
layerEnvelopeR – [in] the tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
layerEnvelopeZ – [in] the tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
defaultLayerThickness – [in] In case no surfaces (to be contained by the layer) are handed over, the layer thickness will be set to this value
sortSubDetectors – [in]
std::function
which should be used in order to sort all sub detectors (=all Detelements collected by the methodcollectSubDetectors()
) 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.gctx – The geometry context to use
matDecorator – is the material decorator that loads material maps
geometryIdentifierHook – Hook to apply to surfaces during geometry closure.
- Throws
std::logic_error – if an error in the translation occurs
- Pre
Before using this method make sure, that the preconditions described in DD4hepPlugins are met.
- 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
-
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.
Note
The data of the axes is given in the std::array as {minimum value, maximum value, number of bins}
- Parameters
gridAxis1 – [in] Axis data
gridAxis2 – [in] Axis data
- Returns
The grid
-
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.
Note
The data of the axes is given in the std::array as {minimum value, maximum value, number of bins}
- Parameters
gridAxis1 – [in] Axis data
gridAxis2 – [in] Axis data
gridAxis3 – [in] Axis data
- Returns
The grid
-
Grid2D createGrid2D(const BinUtility &bins, std::function<Acts::Vector2(Acts::Vector3)> &transfoGlobalToLocal)
Create a 2DGrid using a BinUtility.
Also determine the coresponding global to local transform and grid mapping function
- Parameters
bins – [in] BinUtility of the volume to be mapped
transfoGlobalToLocal – [in] Global to local transform to be updated.
- Returns
the 3D grid
-
Grid3D createGrid3D(const BinUtility &bins, std::function<Acts::Vector3(Acts::Vector3)> &transfoGlobalToLocal)
Create a 3DGrid using a BinUtility.
Also determine the coresponding global to local transform and grid mapping function
- Parameters
bins – [in] BinUtility of the volume to be mapped
transfoGlobalToLocal – [in] Global to local transform to be updated.
- Returns
the 3D grid
-
std::shared_ptr<Acts::ProtoSurfaceMaterial> createProtoMaterial(const dd4hep::rec::VariantParameters ¶ms, const std::string &valueTag, const std::vector<std::pair<const std::string, Acts::BinningOption>> &binning, LoggerWrapper logger = getDummyLogger())
Helper method to create proto material - to be called from the addProto(…) methods.
- Parameters
params – An instance of
DD4hep::VariantParameters
valueTag – the xml tag for to ActsExtension to be parsed
binning – the Binning prescription for the ActsExtension
logger – a
LoggerWrapper
for output
-
std::shared_ptr<const CylinderVolumeHelper> cylinderVolumeHelper_dd4hep(Logging::Level loggingLevel = Logging::Level::INFO)
Helper method internally used to create a default Acts::CylinderVolumeBuilder.
-
float deriveEnergyLossBetheQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Derivative of the Bethe energy loss with respect to q/p.
Compute the mean energy loss due to ionisation and excitation.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float deriveEnergyLossLandauQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Derivative of the most probable ionisation energy loss with respect to q/p.
Compute the mean energy loss due to ionisation and excitation.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float deriveEnergyLossMeanQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Derivative of the combined mean energy loss with respect to q/p.
Compute the combined mean energy loss.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float deriveEnergyLossModeQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Derivative of the combined most probable energy loss with respect to q/p.
Compute the combined mean energy loss.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
float deriveEnergyLossRadiativeQOverP(const MaterialSlab &slab, int pdg, float m, float qOverP, float q = UnitConstants::e)
Derivative of the mean radiative energy loss with respect to q/p.
Compute the mean energy loss due to radiative effects at high energies.
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.
- Parameters
slab – The traversed material and its properties
pdg – Particle type PDG identifier
m – Particle mass
qOverP – Particle charge divided by absolute momentum
q – Particle charge, only the magnitude is considered
-
inline constexpr NavigationDirection directionFromStepSize(double value)
-
template<typename container_type, typename container_type_iter = decltype(std::begin(std::declval<container_type>())), typename = decltype(std::end(std::declval<container_type>()))>
constexpr auto enumerate(container_type &&iterable) Helper utility to allow indexed enumeration with structured binding.
Usage:
for (auto [ i, value ] = enumerate(container) ) { … };
with ‘container’ any stl-like container
-
template<typename spacepoint_iterator_t>
std::optional<BoundVector> estimateTrackParamsFromSeed(spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd) Estimate the track parameters on the xy plane from at least three space points.
It assumes the trajectory projection on the xy plane is a circle, i.e. the magnetic field is along global z-axis.
The method is based on V. Karimaki NIM A305 (1991) 187-191: https://doi.org/10.1016/0168-9002(91)90533-V
no weights are used in Karimaki’s fit; d0 is the distance of the point of closest approach to the origin, 1/R is the curvature, phi is the angle of the direction propagation (counter clockwise as positive) at the point of cloest approach.
- Template Parameters
spacepoint_iterator_t – The type of space point iterator
- Parameters
spBegin – is the begin iterator for the space points
spEnd – is the end iterator for the space points
- Returns
optional bound track parameters with the estimated d0, phi and 1/R stored with the indices, eBoundLoc0, eBoundPhi and eBoundQOverP, respectively. The bound parameters with other indices are set to zero.
-
template<typename spacepoint_iterator_t>
std::optional<BoundVector> estimateTrackParamsFromSeed(const GeometryContext &gctx, spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd, const Surface &surface, Vector3 bField, ActsScalar bFieldMin, ActsScalar mass = 139.57018 * UnitConstants::MeV) Estimate the full track parameters from three space points.
This method is based on the conformal map transformation. It estimates the full bound track parameters, i.e. (loc0, loc1, phi, theta, q/p, t) at the bottom space point. The bottom space is assumed to be the first element in the range defined by the iterators. It must lie on the surface provided for the representation of the bound track parameters. The magnetic field (which might be along any direction) is also necessary for the momentum estimation.
It resembles the method used in ATLAS for the track parameters estimated from seed, i.e. the function InDet::SiTrackMaker_xk::getAtaPlane here: https://acode-browser.usatlas.bnl.gov/lxr/source/athena/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx
- Template Parameters
spacepoint_iterator_t – The type of space point iterator
- Parameters
gctx – is the geometry context
spBegin – is the begin iterator for the space points
spEnd – is the end iterator for the space points
surface – is the surface of the bottom space point. The estimated bound track parameters will be represented also at this surface
bField – is the magnetic field vector
bFieldMin – is the minimum magnetic field required to trigger the estimation of q/pt
mass – is the estimated particle mass
- Returns
optional bound parameters
-
Acts::InterpolatedBFieldMap<Acts::detail::Grid<Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>> fieldMapRZ(const std::function<size_t(std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ)> &localToGlobalBin, std::vector<double> rPos, std::vector<double> zPos, std::vector<Acts::Vector2> bField, double lengthUnit = UnitConstants::mm, double BFieldUnit = UnitConstants::T, bool firstQuadrant = false)
Method to setup the FieldMap.
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
[](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) { return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1)); }
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The function localToGlobalBin determines how the magnetic field was stored in the vector in respect to the grid values
Note
If
firstQuadrant
is true will create a field that is symmetric for all quadrants. e.g. we have the grid values r={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the r-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.- Parameters
localToGlobalBin – Function mapping the local bins of r,z to the global bin of the map magnetic field value
rPos – [in] Values of the grid points in r
zPos – [in] Values of the grid points in z
bField – [in] The magnetic field values inr r and z for all given grid points stored in a vector
lengthUnit – [in] The unit of the grid points
BFieldUnit – [in] The unit of the magnetic field
firstQuadrant – [in] Flag if set to true indicating that only the first quadrant of the grid points and the BField values has been given.
- Returns
A field map instance for use in interpolation.
-
Acts::InterpolatedBFieldMap<Acts::detail::Grid<Acts::Vector3, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>> fieldMapXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ)> &localToGlobalBin, std::vector<double> xPos, std::vector<double> yPos, std::vector<double> zPos, std::vector<Acts::Vector3> bField, double lengthUnit = UnitConstants::mm, double BFieldUnit = UnitConstants::T, bool firstOctant = false)
Method to setup the FieldMap.
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
[](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) { return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2)) + binsXYZ.at(1) * nBinsXYZ.at(2) + binsXYZ.at(2)); }
Note
The grid point values
xPos
,yPos
andzPos
do not need to be sorted or unique (this will be done inside the function)Note
The function
localToGlobalBin
determines how the magnetic field was stored in the vector in respect to the grid valuesNote
If
firstOctant
is true, the function will assume a symmetrical field for all quadrants. e.g. we have the grid values z={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the z-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.- Parameters
localToGlobalBin – Function mapping the local bins of x,y,z to the global bin of the map magnetic field value
xPos – [in] Values of the grid points in x
yPos – [in] Values of the grid points in y
zPos – [in] Values of the grid points in z
bField – [in] The magnetic field values inr r and z for all given grid points stored in a vector
lengthUnit – [in] The unit of the grid points
BFieldUnit – [in] The unit of the magnetic field
firstOctant – [in] Flag if set to true indicating that only the first octant of the grid points and the BField values has been given.
- Returns
A field map instance for use in interpolation.
-
void from_json(const nlohmann::json &j, Transform3 &t)
-
void from_json(const nlohmann::json &j, BinningData &bd)
-
void from_json(const nlohmann::json &j, BinUtility &bu)
-
void from_json(const nlohmann::json &j, Material &t)
-
void from_json(const nlohmann::json &j, MaterialSlab &t)
-
void from_json(const nlohmann::json &j, MaterialSlabMatrix &t)
-
void from_json(const nlohmann::json &j, volumeMaterialPointer &t)
-
void from_json(const nlohmann::json &j, surfaceMaterialPointer &t)
-
std::unique_ptr<const Logger> getDefaultLogger(const std::string &name, const Logging::Level &lvl, std::ostream *log_stream = &std::cout)
get default debug output logger
This function returns a pointer to a Logger instance with the following decorations enabled:
time stamps
name of logging instance
debug level
- Parameters
name – [in] name of the logger instance
lvl – [in] debug threshold level
log_stream – [in] output stream used for printing debug messages
- Returns
pointer to logging instance
-
LoggerWrapper getDummyLogger()
-
template<typename T>
T getParam(const std::string &key, dd4hep::DetElement &elt) Helper function to extract a parameter value from a dd4hep detector element from VariantParameters.
- Template Parameters
T – The value type
- Parameters
key – The key of the value to extract
elt – The detector element instance
- Returns
A copy of the value contained in the params instance
-
template<typename T>
T getParamOr(const std::string &key, const dd4hep::DetElement &elt, T alternative) Get a parameter value or an alternative value if either the VariantParameters extension isn’t set, or it doesn’t contain the demanded key.
- Template Parameters
T – The value type
- Parameters
key – The key of the value to extract
elt – The detector element instance
alternative – The value to return if no params are set of the key doesn’t exist
- Returns
The value behind key, or
alternative
-
inline dd4hep::rec::VariantParameters &getParams(dd4hep::DetElement &elt)
Helper function to extract a VariantParameters instance.
- Parameters
elt – The detector element instance
- Returns
The VariantParameters instance
-
inline const dd4hep::rec::VariantParameters &getParams(const dd4hep::DetElement &elt)
Helper function to extract a VariantParameters instance, const version.
- Parameters
elt – The detector element instance
- Returns
The VariantParameters instance
-
std::function<double(Acts::Vector3)> globalToLocalFromBin(Acts::BinningValue &type)
return a function that return the coordinate corresponding to type of bin
- Parameters
type – [in] Type of bin
- Returns
a coordinate transform function
-
constexpr HashedString hashString(std::string_view s)
-
inline bool hasParam(const std::string &key, dd4hep::DetElement &elt)
Check if a detector element has a key set in its VariantParameters.
- Parameters
key – The key to check existance for
elt – The detector element instance
- Returns
True if the element has VariantParameters and the key exists, false if either of these is not true
-
inline bool hasParams(dd4hep::DetElement &elt)
Check if a detector element has VariantParameters set.
- Parameters
elt – The detector element instance
- Returns
True if the VariantParameters exist, false if not
-
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>>
inline T interpolate(const Point1 &position, const Point2 &lowerCorner, const Point3 &upperCorner, const std::array<T, N> &values) performs linear interpolation inside a hyper box
Note
Given
U
andV
of value typeT
as well as twodouble
a
andb
, then the following must be a valid expressiona * U + b * V
yielding an object which is (implicitly) convertible toT
.All
Point
types must represent d-dimensional positions and support coordinate access usingoperator
[] which should return adouble
(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 providedPoint
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 a0
stands for a lower bound along this axis and a1
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) andupperCorner
= (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
- Template Parameters
T – type of values to be interpolated
N – number of hyper box corners
Point1 – type specifying geometric positions
Point2 – type specifying geometric positions
Point3 – type specifying geometric positions
- Parameters
position – [in] position to which to interpolate
lowerCorner – [in] generalized lower-left corner of hyper box (containing the minima of the hyper box along each dimension)
upperCorner – [in] generalized upper-right corner of hyper box (containing the maxima of the hyper box along each dimension)
values – [in] field values at the hyper box corners sorted in the canonical order defined below.
- Returns
interpolated value at given position
- Pre
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\).
-
std::error_code make_error_code(Acts::MagneticFieldError e)
-
std::error_code make_error_code(Acts::SurfaceError e)
-
std::error_code make_error_code(EigenStepperError e)
-
std::error_code make_error_code(Acts::PropagatorError e)
-
std::error_code make_error_code(Acts::CombinatorialKalmanFilterError e)
-
std::error_code make_error_code(Acts::MultiStepperError e)
-
std::error_code make_error_code(Acts::VertexingError e)
-
std::error_code make_error_code(Acts::KalmanFitterError e)
-
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) Build an octree from a list of bounding boxes.
Note
store
andprims
do not need to contain the same objects.store
is only used to pass ownership back to the caller while preserving memory location.- Template Parameters
box_t – Works will all box types.
- Parameters
store – Owns the created boxes by means of
std::unique_ptr
.prims – Boxes to store. This is a read only vector.
max_depth – No subdivisions beyond this level.
envelope1 – Envelope to add/subtract to dimensions in all directions.
- Returns
Pointer to the top most bounding box, containing the entire octree
-
inline constexpr PdgParticle makeAbsolutePdgParticle(PdgParticle pdg)
Convert an anti-particle to its particle and leave particles as-is.
-
template<typename InputVector>
inline auto makeCurvilinearUnitU(const Eigen::MatrixBase<InputVector> &direction) Construct the first curvilinear unit vector
U
for the given 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.
- Parameters
direction – is the input direction vector
- Returns
a normalized vector in the x-y plane orthogonal to the direction.
-
template<typename InputVector>
inline auto makeCurvilinearUnitVectors(const Eigen::MatrixBase<InputVector> &direction) Construct the curvilinear unit vectors
U
andV
for the given direction.With
T
the normalized input direction, the three vectorsU
,V
, andT
form an orthonormal basis set, i.e. they satisfyU 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.- Parameters
direction – is the input direction vector
- Returns
normalized unit vectors
U
andV
orthogonal to the direction.
-
template<typename T>
inline Eigen::Matrix<T, 3, 1> makeDirectionUnitFromPhiEta(T phi, T eta) Construct a normalized direction vector from phi angle and pseudorapidity.
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 mismatched input types.
- Parameters
phi – is the direction angle in the x-y plane.
eta – is the pseudorapidity towards the z-axis.
-
template<typename T>
inline Eigen::Matrix<T, 3, 1> makeDirectionUnitFromPhiTheta(T phi, T theta) Construct a normalized direction vector from phi and theta angle.
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 mismatched input types.
- Parameters
phi – is the direction angle in radian in the x-y plane.
theta – is the polar angle in radian towards the z-axis.
-
template<typename parameters_t, typename covariance_t, typename indices_t, typename ...tail_indices_t>
auto makeMeasurement(const SourceLink &source, const Eigen::MatrixBase<parameters_t> ¶ms, const Eigen::MatrixBase<covariance_t> &cov, indices_t index0, tail_indices_t... tailIndices) -> Measurement<indices_t, 1u + sizeof...(tail_indices_t)> Construct a fixed-size measurement for the given indices.
This helper function can be used to create a fixed-size measurement using an explicit set of indices, e.g.
auto m = makeMeasurement(s, p, c, eBoundLoc0, eBoundTime);
for a 2d measurement w/ one position and time.
Note
The indices must be ordered and must be consistent with the content of parameters and covariance.
- Template Parameters
parameters_t – Input parameters vector type
covariance_t – Input covariance matrix type
indices_t – Parameter index type, determines the full parameter space
tail_indices_t – Helper types required to support variadic arguments; all types must be convertibale to
indices_t
.
- Parameters
source – The link that connects to the underlying detector readout
params – Measured parameters values
cov – Measured parameters covariance
index0 – Required parameter index, measurement must be at least 1d
tailIndices – Additional parameter indices for larger measurements
- Returns
Fixed-size measurement w/ the correct type and given inputs
-
MaterialGrid2D mapMaterialPoints(Grid2D &grid)
Average the material collected in a 2D grid and use it to create a 2D material grid.
- Parameters
grid – [in] The material collecting grid coordinate
- Returns
The average material grid decomposed into classification numbers
-
MaterialGrid3D mapMaterialPoints(Grid3D &grid)
Average the material collected in a 3D grid and use it to create a 3D material grid.
- Parameters
grid – [in] The material collecting grid coordinate
- Returns
The average material grid decomposed into classification numbers
-
MaterialMapper<detail::Grid<Material::ParametersVector, detail::EquidistantAxis, detail::EquidistantAxis>> materialMapperRZ(const std::function<size_t(std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ)> &materialVectorToGridMapper, std::vector<double> rPos, std::vector<double> zPos, std::vector<Material> material, double lengthUnit = UnitConstants::mm)
Method to setup the MaterialMapper.
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
[](std::array<size_t, 2> binsRZ, std::array<size_t, 2> nBinsRZ) { return (binsRZ.at(0) * nBinsRZ.at(1) + binsRZ.at(1)); }
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The function localToGlobalBin determines how the material was stored in the vector in respect to the grid values
- Parameters
materialVectorToGridMapper – [in] Function mapping the vector of material to the map of material values
rPos – [in] Values of the grid points in r
zPos – [in] Values of the grid points in z
material – [in] The material classification values in r and z for all given grid points stored in a vector
lengthUnit – [in] The unit of the grid points
-
MaterialMapper<detail::Grid<Material::ParametersVector, detail::EquidistantAxis, detail::EquidistantAxis, detail::EquidistantAxis>> materialMapperXYZ(const std::function<size_t(std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ)> &materialVectorToGridMapper, std::vector<double> xPos, std::vector<double> yPos, std::vector<double> zPos, std::vector<Material> material, double lengthUnit = UnitConstants::mm)
Method to setup the MaterialMapper.
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
[](std::array<size_t, 3> binsXYZ, std::array<size_t, 3> nBinsXYZ) { return (binsXYZ.at(0) * (nBinsXYZ.at(1) * nBinsXYZ.at(2)) + binsXYZ.at(1) * nBinsXYZ.at(2) + binsXYZ.at(2)); }
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The values do not need to be sorted or unique (this will be done inside the function)
Note
The function localToGlobalBin determines how the material was stored in the vector in respect to the grid values
- Parameters
materialVectorToGridMapper – [in] Function mapping the vector of material to the map of material values
xPos – [in] Values of the grid points in x
yPos – [in] Values of the grid points in y
zPos – [in] Values of the grid points in z
material – [in] The material classification values in x, y and z for all given grid points stored in a vector
lengthUnit – [in] The unit of the grid points
-
template<typename Derived>
auto matrixToBitset(const Eigen::PlainObjectBase<Derived> &m) Convert an integer matrix to a bitset.
Note
How the bits are ordered depends on the storage type of the matrix being converted (row-major or col-major)
- Template Parameters
Derived – Eigen base concrete type
- Parameters
m – Matrix that is converted
- Returns
The converted bitset.
-
inline bool operator!=(const DigitizationSourceLink &lhs, const DigitizationSourceLink &rhs)
-
inline bool operator!=(const SurfaceBounds &lhs, const SurfaceBounds &rhs)
-
inline std::ostream &operator<<(std::ostream &os, IntersectionStatus status)
Ostream-operator for the IntersectionStatus enum.
-
std::ostream &operator<<(std::ostream &os, TrackStatePropMask mask)
-
std::ostream &operator<<(std::ostream &os, 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.
-
inline std::ostream &operator<<(std::ostream &os, BoundarySurfaceFace &face)
-
template<typename T, size_t D>
std::ostream &operator<<(std::ostream &os, const Ray<T, D> &ray) Overload of the outstream operator.
- Parameters
os – The out stream
ray – The ray to write to
os
- Returns
The outstream given in
os
-
std::ostream &operator<<(std::ostream &sl, const GlueVolumesDescriptor &gvd)
-
std::ostream &operator<<(std::ostream &os, const MaterialSlab &materialSlab)
-
inline std::ostream &operator<<(std::ostream &os, const SurfaceBounds &sb)
-
inline std::ostream &operator<<(std::ostream &os, const IVisualization3D &hlp)
Overload of the << operator to facilitate writing to streams.
- Parameters
os – The output stream
hlp – The helper instance
-
std::ostream &operator<<(std::ostream &os, MaterialUpdateStage matUpdate)
-
std::ostream &operator<<(std::ostream &os, const Material &material)
-
std::ostream &operator<<(std::ostream &sl, const Volume &vol)
Overload of << operator for std::ostream for debug output.
-
std::ostream &operator<<(std::ostream &os, GeometryIdentifier id)
-
std::ostream &operator<<(std::ostream &sl, const VolumeBounds &vb)
Overload of << operator for std::ostream for debug output.
-
inline std::ostream &operator<<(std::ostream &os, const ConstrainedStep &step)
-
std::ostream &operator<<(std::ostream &sl, const Extent &rhs)
Overload of << operator for std::ostream for debug output.
-
template<typename indices_t>
std::ostream &operator<<(std::ostream &os, const VariantMeasurement<indices_t> &vm)
-
std::ostream &operator<<(std::ostream &sl, const BinUtility &bgen)
Overload of << operator for std::ostream for debug output.
-
template<typename T, typename U, size_t V>
std::ostream &operator<<(std::ostream &os, const AxisAlignedBoundingBox<T, U, V> &box) Overload of the << operator for bounding boxes.
- Template Parameters
T – entity type
U – value type
V – dimension
- Parameters
os – The output stream
box – The bounding box
- Returns
The given output stream.
-
inline std::ostream &operator<<(std::ostream &os, const std::tuple<const Surface&, const GeometryContext&> &tup)
Print surface information to the provided stream.
Internally invokes the
surface.toStream(...)
-method. This can be easily used e.g. likestd::cout << std::tie(surface, geometryContext);
-
inline bool operator==(const DigitizationSourceLink &lhs, const DigitizationSourceLink &rhs)
-
inline bool operator==(const SurfaceBounds &lhs, const SurfaceBounds &rhs)
-
inline bool operator==(const VolumeBounds &lhs, const VolumeBounds &rhs)
-
Acts::InterpolatedBFieldMap<Acts::detail::Grid<Acts::Vector2, Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>> solenoidFieldMap(std::pair<double, double> rlim, std::pair<double, double> zlim, std::pair<size_t, size_t> nbins, const SolenoidBField &field)
Function which takes an existing SolenoidBField instance and creates a field mapper by sampling grid points from the analytical solenoid field.
- Parameters
rlim – pair of r bounds
zlim – pair of z bounds
nbins – pair of bin counts
field – the solenoid field instance
- Returns
A field map instance for use in interpolation.
-
inline void sortDetElementsByID(std::vector<dd4hep::DetElement> &det)
Sort function which sorts dd4hep::DetElement by their ID.
- Parameters
det – [inout] the dd4hep::DetElements to be sorted
Converstion to surfaceBounds from json.
The type is given as a template argument in order to be able to construct the correct fitting types for surfaces.
- Parameters
j – the read-in json object
- Returns
a shared_ptr to a surface object for type polymorphism
-
std::shared_ptr<Surface> surfaceFromJson(const nlohmann::json &j)
Converstion to Surface from jsonn.
- Parameters
j – the read-in json object
- Returns
a shared_ptr to a surface object for type polymorphism
Converstion to Surface from json in correct type.
The type is given as a template argument in order to be able to construct the correct fitting types for surfaces.
- Parameters
j – the read-in json object
- Returns
a shared_ptr to a typed surface object for type polymorphism
-
template<template<size_t> class Callable, size_t N, size_t NMAX, typename ...Args>
auto template_switch(size_t v, Args&&... args) Dispatch a call based on a runtime value on a function taking the value at compile time.
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 betweenN
andNMAX
, attempting to find the right instance. Because the cascade is visible to the compiler entirely, it should be able to optimize.Note
Callable
is expected to have a static member functioninvoke
that is callable withArgs
- Template Parameters
Callable – Type which takes a size_t as a compile time param
N – Value from which to start the dispatch chain, i.e. 0 in most cases
NMAX – Maximum value up to which to attempt a dispatch
- Parameters
v – The runtime value to dispatch on
args – Additional arguments passed to
Callable::invoke()
.
-
void to_json(nlohmann::json &j, const Transform3 &t)
-
void to_json(nlohmann::json &j, const BinningData &bd)
-
void to_json(nlohmann::json &j, const BinUtility &bu)
-
void to_json(nlohmann::json &j, const Material &t)
-
void to_json(nlohmann::json &j, const SurfaceBounds &bounds)
-
void to_json(nlohmann::json &j, const TrackingVolumeAndMaterial &volume)
Conversion of a pair of tracking volume and material used for the material mapping.
-
void to_json(nlohmann::json &j, const MaterialSlab &t)
-
void to_json(nlohmann::json &j, const TrackingVolumePointer &volume)
Conversion of a const pointer on a tracking volume used to write the geometry.
Conversion of a tracking volume.
-
void to_json(nlohmann::json &j, const SurfaceAndMaterialWithContext &surface)
Conversion of a pair of surface and material used for the material mapping.
-
void to_json(nlohmann::json &j, const volumeMaterialPointer &t)
-
void to_json(nlohmann::json &j, const Surface &surface)
Non-contextual conversion of a surface.
Note
it will take the default context
-
void to_json(nlohmann::json &j, const surfaceMaterialPointer &t)
Non-contextual conversion of a surface.
Note
it will take the default context
-
void toJson(nlohmann::json &j, const Surface &surface, const Acts::GeometryContext &gctx)
Contextual conversion of a surface.
- Parameters
j – the json to be filled
surface – the surface to be converted
gctx – the geometry context for this
Contextual conversion of a surface.
- Parameters
j – the json to be filled
surface – the surface to be converted
gctx – the geometry context for this
-
template<typename derived_t>
inline std::string toString(const Eigen::MatrixBase<derived_t> &matrix, int precision = 4, const std::string &offset = "") Print out a matrix in a structured way.
- Template Parameters
derived_t – Type of the matrix
- Parameters
matrix – The matrix to print
precision – Numeric output precision
offset – Offset in front of matrix lines
- Returns
The printed string
-
inline std::string toString(const Acts::Translation3 &translation, int precision = 4)
Print out a translation in a structured way.
- Parameters
translation – The translation to print
precision – Numeric output precision
- Returns
The printed string
-
inline std::string toString(const Acts::Transform3 &transform, int precision = 4, const std::string &offset = "")
Print out a transform in a structured way.
- Parameters
transform – The transform to print
precision – Numeric output precision
offset – Offset in front of matrix lines
- Returns
The printed string
-
template<typename external_spacepoint_t>
LinCircle transformCoordinates(InternalSpacePoint<external_spacepoint_t> &sp, InternalSpacePoint<external_spacepoint_t> &spM, bool bottom) Transform two spacepoints to a u-v space circle.
This function is a non-vectorized version of transformCoordinates.
- Template Parameters
external_spacepoint_t – The external spacepoint type.
- Parameters
sp – [in] The first spacepoint to use, either a bottom or top.
spM – [in] The middle spacepoint to use.
bottom – [in] Should be true if sp is a bottom SP.
-
template<typename external_spacepoint_t, typename callable_t>
LinCircle transformCoordinates(external_spacepoint_t &sp, external_spacepoint_t &spM, bool bottom, callable_t &&extractFunction)
-
template<typename external_spacepoint_t>
void transformCoordinates(std::vector<InternalSpacePoint<external_spacepoint_t>*> &vec, InternalSpacePoint<external_spacepoint_t> &spM, bool bottom, std::vector<LinCircle> &linCircleVec) Transform a vector of spacepoints to u-v space circles with respect to a given middle spacepoint.
- Template Parameters
external_spacepoint_t – The external spacepoint type.
- Parameters
vec – [in] The list of bottom or top spacepoints
spM – [in] The middle spacepoint.
bottom – [in] Should be true if vec are bottom spacepoints.
linCircleVec – [out] The output vector to write to.
-
template<typename external_spacepoint_t, typename callable_t>
void transformCoordinates(std::vector<external_spacepoint_t*> &vec, external_spacepoint_t &spM, bool bottom, std::vector<LinCircle> &linCircleVec, callable_t &&extractFunction)
-
std::tuple<VariantCovariance, VariantTransportJacobian> transportCovarianceToBound(const GeometryContext &gctx, const Surface &surface, const FreeVector ¶meters, CovarianceCache &cCache)
Transport the covariance to a new (surface) bound definition.
- Parameters
gctx – [in] The current geometry context
surface – [in] The surface of the bound representation
parameters – [in] The free parametrisation on the surface
cCache – [in,out] the covariance cache (to be modified)
- Returns
a variant transport jacobian
-
std::tuple<VariantCovariance, VariantTransportJacobian> transportCovarianceToCurvilinear(const Vector3 &direction, CovarianceCache &cCache)
Transport the covariance to a new (curvilinear) bound definition.
- Parameters
direction – [in] The track direction at the new curvilinear definition
cCache – [in,out] the covariance cache (to be modified)
-
std::tuple<VariantCovariance, VariantTransportJacobian> transportCovarianceToFree(CovarianceCache &cCache)
Transport the covariance to a new free definition.
- Parameters
cCache – [in,out] the covariance cache (to be modified)
Helper function to unpack a vector of
shared_ptr
into a vector of raw pointers.- Template Parameters
T – the stored type
- Parameters
items – The vector of
shared_ptr
- Returns
The unpacked vector
Helper function to unpack a vector of
shared_ptr
into a vector of raw pointers (const version)- Template Parameters
T – the stored type
- Parameters
items – The vector of
shared_ptr
- Returns
The unpacked vector
-
template<typename L, typename A, typename B>
auto visit_measurement(A &¶m, 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.
Note
No requirements on
A
andB
are made, to enable a single overload for both const and non-const matrices/vectors.- Template Parameters
L – The lambda type
A – The parameter vector type
B – The covariance matrix type
- Parameters
param – The parameter vector
cov – The covariance matrix
dim – The actual dimension as a runtime value
lambda – The lambda to call with the statically sized subsets
-
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.
This method creates an Acts::CylinderVolumeBuilder from a sub detector (= ‘compound’ DetElement or DetElements which are declared as ‘isBarrel’ or ‘isBeampipe’ by their extension.
- Attention
The default thickness should be set thin enough that no touching or overlapping with the next layer can happen.
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
Note
equidistant binningtype is recommended because it is faster not only while building the geometry but also for look up during the extrapolation
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.
- Parameters
subDetector – [in] the DD4hep DetElement of the subdetector
loggingLevel – [in] is the debug logging level of the conversion and geometry building
bTypePhi – [in] is how the sensitive surfaces (modules) should be binned in a layer in phi direction.
bTypeR – [in] is how the sensitive surfaces (modules) should be binned in a layer in r direction
bTypeZ – [in] is how the sensitive surfaces (modules) should be binned in a layer in z direction
layerEnvelopeR – [in] the tolerance added to the geometrical extension in r of the layers contained to build the volume envelope around
layerEnvelopeZ – [in] the tolerance added to the geometrical extension in z of the layers contained to build the volume envelope around
defaultLayerThickness – [in] In case no surfaces (to be contained by the layer) are handed over, the layer thickness will be set to this value
- Returns
std::shared_ptr the Acts::CylinderVolumeBuilder which can be used to build the full tracking geometry
-
template<typename external_spacepoint_t, typename sp_range_t>
bool xyzCoordinateCheck(Acts::SeedfinderConfig<external_spacepoint_t> config, sp_range_t sp, const double *spacepointPosition, const float toleranceParam, double *outputCoordinates) Check the compatibility of spacepoint coordinates in xyz assuming the Bottom-Middle direction with the strip meassument details.
- Template Parameters
external_spacepoint_t – The external spacepoint type.
sp_range_t – Container type for the space point collections.
- Parameters
config – [in] Seedfinder config containing the delegates to the strip measurement details.
sp – [in] Input space point used in the check.
spacepointPosition – [in] Spacepoint coordinates in xyz plane.
toleranceParam – [in] Parameter used to evaluate if spacepointPosition is inside the detector elements.
outputCoordinates – [out] The output vector to write to.
- Returns
Boolean that says if spacepoint is compatible with being inside the detector element.
-
template<typename RA, typename RB>
auto zip(RA &ra, RB &rb) Function that allows to zip two ranges to be used in a range-based for loop.
This is a very basic implementation for two ranges, but could relatively easily be extended with variadic templates.
Note
the behaviour is undefined if the ranges do not have equal range
- Template Parameters
RA – The first range type
RB – The second range type
- Parameters
ra – The first range
rb – The second range
Variables
-
static std::vector<std::string> boundTypes = {"ConeBounds", "CylinderBounds", "DiamondBounds", "RadialBounds", "EllipseBounds", "LineBounds", "RectangleBounds", "TrapezoidBounds", "TriangleBounds", "DiscTrapezoidBounds", "ConvexPolygonBounds", "AnnulusBounds", "OtherBounds"}
-
template<typename fitter>
constexpr bool LinearizerConcept = Acts::Concepts::Linearizer::LinearizerConcept<fitter>::value
-
constexpr int PolygonDynamic = -1
Tag to trigger specialization of a dynamic polygon.
-
static const std::vector<BinningValue> s_binningValues = {binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta, binMag}
static list of all binning values
-
static constexpr ActsScalar s_curvilinearProjTolerance = 0.999995
Tolerance for not being within curvilinear projection this allows using the same curvilinear frame to eta = 6, validity tested with IntegrationTests/PropagationTest.
-
static constexpr ActsScalar s_epsilon = 3 * std::numeric_limits<ActsScalar>::epsilon()
Tolerance for being numerical equal for geometry building.
-
static const InfiniteBounds s_noBounds = {}
-
static constexpr ActsScalar s_onSurfaceTolerance = 1e-4
Tolerance for being on Surface.
Note
This is intentionally given w/o an explicit unit to avoid having to include the units header unneccessarily. With the native length unit of mm this corresponds to 0.1um.
-
static const Transform3 s_planeXY = Transform3::Identity()
-
static const Transform3 s_planeYZ = AngleAxis3(0.5 * M_PI, Vector3::UnitY()) * AngleAxis3(0.5 * M_PI, Vector3::UnitZ()) * Transform3::Identity()
-
static const Transform3 s_planeZX = AngleAxis3(-0.5 * M_PI, Vector3::UnitX()) * AngleAxis3(-0.5 * M_PI, Vector3::UnitZ()) * Transform3::Identity()
-
static ViewConfig s_viewFiltered = ViewConfig({255, 255, 0})
-
static ViewConfig s_viewGrid = ViewConfig({220, 0, 0})
-
static ViewConfig s_viewLine = ViewConfig({0, 0, 220})
-
static ViewConfig s_viewMeasurement = ViewConfig({255, 102, 0})
-
static ViewConfig s_viewParameter = ViewConfig({0, 0, 255})
-
static ViewConfig s_viewPassive = ViewConfig({240, 280, 0})
-
static ViewConfig s_viewPredicted = ViewConfig({51, 204, 51})
-
static ViewConfig s_viewSensitive = ViewConfig({0, 180, 240})
-
static ViewConfig s_viewSmoothed = ViewConfig({0, 102, 255})
-
static ViewConfig s_viewVolume = ViewConfig({220, 220, 0})
-
template<typename accessor>
constexpr bool SourceLinkAccessorConcept = Acts::Concepts::SourceLinkAccessor::SourceLinkAccessorConcept<accessor>::value
-
template<typename stepper, typename state = typename stepper::State>
constexpr bool StepperConcept = Acts::Concepts::Stepper::SingleStepperConcept<stepper, state>::value || Acts::Concepts::Stepper::MultiStepperConcept<stepper, state>::value
-
template<typename stepper>
constexpr bool StepperStateConcept = Acts::Concepts::Stepper::StepperStateConcept<stepper> || Acts::Concepts::Stepper::MultiStepperStateConcept<stepper>
-
static std::vector<std::string> surfaceTypes = {"ConeSurface", "CylinderSurface", "DiscSurface", "PerigeeSurface", "PlaneSurface", "StrawSurface", "CurvilinearSurface"}
-
template<typename finder>
constexpr bool VertexFinderConcept = Acts::Concepts::VertexFinder::VertexFinderConcept<finder>::value
-
template<typename fitter>
constexpr bool VertexFitterConcept = Acts::Concepts::VertexFitter::VertexFitterConcept<fitter>::value
-
constexpr Envelope zeroEnvelope = {0., 0}
-
constexpr ExtentEnvelope zeroEnvelopes = {zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope}
-
class AbstractVolume : public Acts::Volume
- #include <Acts/Geometry/AbstractVolume.hpp>
AbstractVolume description inside the tracking realm.
This is the purely geometrical object volume.
The Acts::AbstractVolume is constructed by giving a pointer to a Transform3 and a pointer to Acts::VolumeBounds, this implies that the ownership of the objects pointed to is passed as well. For memory optimisation, the AbstractVolume can also be constructed with shared_ptr objects.
A Acts::AbstractVolume is at first a collection class of Acts::BoundarySurface, the vector of Acts::BoundarySurface is returned by the Acts::VolumeBounds that carry a decompose method.
Boundary surfaces can be shared between AbstractVolumes to enhance automatic navigation between AbstractVolumes, therefor they are reference counted by a std::shared_ptr holder class.
Public Functions
-
AbstractVolume(const Transform3 &transform, VolumeBoundsPtr volbounds)
Constructor with shared Transform3*, VolumeBounds*.
- Parameters
transform – is the gobal 3d transformation into the volume frame
volbounds – is the boundary definition
-
AbstractVolume(const AbstractVolume &vol) = default
-
AbstractVolume() = delete
-
~AbstractVolume() override = default
-
const std::vector<BoundarySurfacePtr> &boundarySurfaces() const
Method to return the BoundarySurfaces.
- Returns
the vector of boundary surfaces
-
AbstractVolume &operator=(const AbstractVolume &vol) = delete
-
AbstractVolume(const Transform3 &transform, VolumeBoundsPtr volbounds)
-
class AccumulatedMaterialSlab
- #include <Acts/Material/AccumulatedMaterialSlab.hpp>
Accumulate material properties from multiple hits/track and multiple tracks.
This is a helper class for the
SurfaceMaterialMapper
to handle material accumulation and averaging for one surface bin. The accumulation procedure is done in two steps:The per-track store accumulates material steps from one track/particle. Multiple material steps can be assigned to the same bin time by one particle, e.g. if the simulation has created more than one step in the material or if several components are compressed into one description. Multiple steps are treated as if they are passed one after the other.
The total store averages the accumulated material properties over all tracks. Each track contributes equally.
Public Functions
-
void accumulate(MaterialSlab slabAlongTrack, float pathCorrection = 1)
Add the material to the current per-track store.
The recoded material slab is assumed to be defined along the track direction. The track can have non-perpendicular incidence on the surface and the recorded slab has to be projected along the surface normal. The path correction gives the scaling factor from normal incidence to the recorded incidence as provided by the
Surface
interface.Vacuum steps with a non-zero thickness can be added to account for holes in material structures.
- Parameters
slabAlongTrack – Recorded equivalent material slab for this step
pathCorrection – Correction factor due to non-perpendicular incident
-
std::pair<MaterialSlab, unsigned int> totalAverage() const
Return the average material properties from all accumulated tracks.
Only contains the information up to the last
.trackAverage(...)
call. If there have been additional calls to.accumulate(...)
afterwards, the information is not part of the total average. The thickness corresponds to the average thickness seen by the tracks.- Returns
Average material properties and the number of contributing tracks
-
std::pair<float, unsigned int> totalVariance() const
Return the material variance from all accumulated tracks.
Only contains the information up to the last
.trackVariance(...)
call. If there have been additional calls to.accumulate(...)
afterwards, the information is not part of the total average. The number of tracks is only opdated on the call of.trackAverage(...)
- Returns
Average material properties and the number of contributing tracks
-
void trackAverage(bool useEmptyTrack = false)
Add the accumulated material for the current track to the total average.
This finishes the material accumulation for the current track and resets the per-track store. Subsequent calls to
.accumulate(...)
will start accumulating material for a new track.Each track contributes equally to the total average regardless of its measured path within the material. An empty per-track store, i.e. vanishing per-track material thickness, does not contribute to the total unless explicitely requested.
- Parameters
useEmptyTrack – indicate whether to consider an empty track store
-
void trackVariance(MaterialSlab slabReference, bool useEmptyTrack = false)
Use the accumulated material to update the material variance.
The material variance can be used to optimised the mapping process as it should be inversly proportionnal to the map quality
- Parameters
slabReference – reference slab (from the map) used to compute the variance
useEmptyTrack – indicate whether to consider an empty track store
-
class AccumulatedSurfaceMaterial
- #include <Acts/Material/AccumulatedSurfaceMaterial.hpp>
This class is used by the SurfaceMaterialMapper in order to accumulate/collect material information during the mapping process.
It performs event- and run-average when called, and returns a new SurfaceMaterial object as a unique_ptr after finalisation
Public Types
-
using AccumulatedMatrix = std::vector<AccumulatedVector>
-
using AccumulatedVector = std::vector<AccumulatedMaterialSlab>
Public Functions
-
AccumulatedSurfaceMaterial(double splitFactor = 0.)
Default Constructor - for homogeneous material.
- Parameters
splitFactor – is the pre/post splitting directive
-
AccumulatedSurfaceMaterial(const BinUtility &binUtility, double splitFactor = 0.)
Explicit constructor with only full MaterialSlab, for one-dimensional binning.
The split factors:
1. : oppositePre
0. : alongPre ===> 1 Dimensional array
- Parameters
binUtility – defines the binning structure on the surface
splitFactor – is the pre/post splitting directive
-
AccumulatedSurfaceMaterial(const AccumulatedSurfaceMaterial &asma) = default
Copy Constructor.
- Parameters
asma – is the source object to be copied
-
AccumulatedSurfaceMaterial(AccumulatedSurfaceMaterial &&asma) = default
Copy Move Constructor.
- Parameters
asma – is the source object to be copied
-
~AccumulatedSurfaceMaterial() = default
Destructor.
-
std::array<size_t, 3> accumulate(const Vector2 &lp, const MaterialSlab &mp, double pathCorrection = 1.)
Assign a material properites object.
- Parameters
lp – local position for the bin assignment
mp – material properties to be assigned
pathCorrection – Correction factor for the effective path length
- Returns
the bin triple to which the material was assigned
-
std::array<size_t, 3> accumulate(const Vector3 &gp, const MaterialSlab &mp, double pathCorrection = 1.)
Assign a material properites object.
- Parameters
gp – global position for the bin assignment
mp – material properties to be assigned
pathCorrection – Correction factor for the effective path length
- Returns
the bin triple to which the material was assigned
-
inline const AccumulatedMatrix &accumulatedMaterial() const
Access to the accumulated material.
-
inline const BinUtility &binUtility() const
Return the BinUtility.
-
AccumulatedSurfaceMaterial &operator=(AccumulatedSurfaceMaterial &&asma) = default
Assignment Move operator.
- Parameters
asma – is the source object to be copied
-
AccumulatedSurfaceMaterial &operator=(const AccumulatedSurfaceMaterial &asma) = default
Assignment operator.
- Parameters
asma – is the source object to be copied
-
inline double splitFactor() const
Access to the split factor.
-
std::unique_ptr<const ISurfaceMaterial> totalAverage()
Total average creates SurfaceMaterial.
-
void trackAverage(const std::vector<std::array<size_t, 3>> &trackBins = {}, bool emptyHit = false)
Average the information accumulated from one mapped track.
- Parameters
trackBins – The bins that were touched by this event
emptyHit – indicator if this is an empty assignment If none is given, the average runs over all bins in the surface map
-
void trackAverage(const Vector3 &gp, bool emptyHit = false)
Average the information accumulated from one mapped track.
- Parameters
gp – global position for the bin assignment
emptyHit – indicator if this is an empty assignment
-
void trackVariance(const std::vector<std::array<size_t, 3>> &trackBins, MaterialSlab slabReference, bool emptyHit = false)
Use the accumulated material to update the material variance.
- Parameters
trackBins – The bins that were touched by this event
emptyHit – indicator if this is an empty assignment
slabReference – reference slab (from the map) used to compute the variance If none is given, the average runs over all bins in the surface map
-
void trackVariance(const Vector3 &gp, MaterialSlab slabReference, bool emptyHit = false)
Use the accumulated material to update the material variance.
- Parameters
gp – global position for the bin assignment
emptyHit – indicator if this is an empty assignment
slabReference – indicator if this is an empty assignment
-
using AccumulatedMatrix = std::vector<AccumulatedVector>
-
class AccumulatedVolumeMaterial
- #include <Acts/Material/AccumulatedVolumeMaterial.hpp>
Accumulate and average volume-based material properties.
This class is intended to be used during the mapping process.
Public Functions
-
void accumulate(const MaterialSlab &mat)
Add one entry with the given material properties.
-
inline const Material &average()
Compute the average material collected so far.
- Returns
Vacuum properties if no matter has been accumulated yet.
-
void accumulate(const MaterialSlab &mat)
-
template<int trkGridSize = 15, typename vfitter_t = DummyVertexFitter<>>
class AdaptiveGridDensityVertexFinder - #include <Acts/Vertexing/AdaptiveGridDensityVertexFinder.hpp>
Vertex finder that makes use of a track density grid.
Each single track is modelled as a 2-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density vector) are superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate. Unlike the GridDensityVertexFinder, this seeder implements an adaptive version where the density grid grows bigger with added tracks.
- Template Parameters
trkGridSize – The 2-dim grid size of a single track, i.e. a single track is modelled as a (trkGridSize x trkGridSize) grid in the d0-z0 plane. Note: trkGridSize has to be an odd value.
Public Types
-
using TrackGridVector = typename GridDensity::TrackGridVector
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline AdaptiveGridDensityVertexFinder(const Config &cfg) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline AdaptiveGridDensityVertexFinder() Default constructor used if InputTrack_t type == BoundTrackParameters.
-
inline AdaptiveGridDensityVertexFinder(const Config &cfg, const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
-
inline AdaptiveGridDensityVertexFinder(const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters with default Config object.
- Parameters
func – Function extracting BoundTrackParameters from InputTrack_t object
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &trackVector, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Function that finds single vertex candidate.
- Parameters
trackVector – Input track collection
vertexingOptions – Vertexing options
state – The state object to cache the density grid and density contributions of each track, to be used if cacheGridStateForTrackRemoval == true
- Returns
Vector of vertices, filled with a single vertex (for consistent interfaces)
-
struct Config
- #include <Acts/Vertexing/AdaptiveGridDensityVertexFinder.hpp>
The Config struct.
Public Functions
-
inline Config(float binSize = 0.1)
- Parameters
binSize – Bin size of grid in mm
-
inline Config(const GridDensity &gDensity)
- Parameters
gDensity – The grid density
Public Members
-
bool cacheGridStateForTrackRemoval = true
-
double d0SignificanceCut = maxD0TrackSignificance * maxD0TrackSignificance
-
bool estimateSeedWidth = false
-
GridDensity gridDensity
-
double maxD0TrackSignificance = 3.5
-
double maxZ0TrackSignificance = 12.
-
double z0SignificanceCut = maxZ0TrackSignificance * maxZ0TrackSignificance
-
inline Config(float binSize = 0.1)
-
struct State
- #include <Acts/Vertexing/AdaptiveGridDensityVertexFinder.hpp>
The State struct.
Only needed if cacheGridStateForTrackRemoval == true
Public Members
-
std::map<const InputTrack_t*, std::pair<int, TrackGridVector>> binAndTrackGridMap
-
bool isInitialized = false
-
std::vector<float> mainGridDensity
-
std::vector<int> mainGridZValues
-
std::map<const InputTrack_t*, bool> trackSelectionMap
-
std::vector<const InputTrack_t*> tracksToRemove
-
std::map<const InputTrack_t*, std::pair<int, TrackGridVector>> binAndTrackGridMap
-
template<int trkGridSize = 15>
class AdaptiveGridTrackDensity - #include <Acts/Vertexing/AdaptiveGridTrackDensity.hpp>
Implements a 1-dim density grid to be filled with track Gaussian distributions.
Each single track is modelled as a 2-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density. Unlike the GaussianGridTrackDensity, the overall density vector grows adaptively with the tracks densities being added to the grid.
- Template Parameters
trkGridSize – The 2-dim grid size of a single track, i.e. a single track is modelled as a (trkGridSize x trkGridSize) grid in the d0-z0 plane. Note: trkGridSize has to be an odd value.
Public Types
-
using TrackGridVector = Eigen::Matrix<float, trkGridSize, 1>
Public Functions
-
inline AdaptiveGridTrackDensity(const Config &cfg)
-
std::pair<int, TrackGridVector> addTrack(const BoundTrackParameters &trk, std::vector<float> &mainGridDensity, std::vector<int> &mainGridZValues) const
Adds a single track to the overall grid density.
- Parameters
trk – The track to be added
mainGridDensity – The main 1-dim density grid along the z-axis
mainGridZValues – The corresponding z-bin values of the track densities along the z-axis
- Returns
A pair storing information about the z-bin position the track was added (int) and the 1-dim density contribution of the track itself
-
Result<float> getMaxZPosition(std::vector<float> &mainGridDensity, const std::vector<int> &mainGridZValues) const
Returns the z position of maximum track density.
- Parameters
mainGridDensity – The main 1-dim density grid along the z-axis
mainGridZValues – The corresponding z-bin values of the track densities along the z-axis
- Returns
The z position of maximum track density
-
Result<std::pair<float, float>> getMaxZPositionAndWidth(std::vector<float> &mainGridDensity, const std::vector<int> &mainGridZValues) const
Returns the z position of maximum track density and the estimated width.
- Parameters
mainGridDensity – The main 1-dim density grid along the z-axis
mainGridZValues – The corresponding z-bin values of the track densities along the z-axis
- Returns
The z position of maximum track density and width
-
void removeTrackGridFromMainGrid(int zBin, const TrackGridVector &trkGrid, std::vector<float> &mainGridDensity, const std::vector<int> &mainGridZValues) const
Removes a track from the overall grid density.
- Parameters
zBin – The center z-bin position the track needs to be removed from
trkGrid – The 1-dim density contribution of the track
mainGridDensity – The main 1-dim density grid along the z-axis
mainGridZValues – The corresponding z-bin values of the track densities along the z-axis
-
struct Config
- #include <Acts/Vertexing/AdaptiveGridTrackDensity.hpp>
The configuration struct.
Public Functions
-
inline Config(float binSize_ = 0.1)
- Parameters
binSize_ – The binSize in mm
Public Members
-
float binSize
-
float maxRelativeDensityDev = 0.01
-
bool useHighestSumZPosition = false
-
inline Config(float binSize_ = 0.1)
-
template<typename vfitter_t, typename sfinder_t>
class AdaptiveMultiVertexFinder - #include <Acts/Vertexing/AdaptiveMultiVertexFinder.hpp>
Implements an iterative vertex finder.
Brief description of the algorithm implemented: TODO
- Template Parameters
vfitter_t – Vertex fitter type
sfinder_t – Seed finder type
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline AdaptiveMultiVertexFinder(Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("AdaptiveMultiVertexFinder", Logging::INFO)) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
logger – The logging instance
-
inline AdaptiveMultiVertexFinder(Config &cfg, std::function<BoundTrackParameters(InputTrack_t)> func, std::unique_ptr<const Logger> logger = getDefaultLogger("AdaptiveMultiVertexFinder", Logging::INFO))
Constructor for user-defined InputTrack_t type != BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
logger – The logging instance
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &allTracks, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Function that performs the adaptive multi-vertex finding.
- Parameters
allTracks – Input track collection
vertexingOptions – Vertexing options
state – State for fulfilling interfaces
- Returns
Vector of all reconstructed vertices
-
struct Config
- #include <Acts/Vertexing/AdaptiveMultiVertexFinder.hpp>
Configuration struct.
Public Functions
Config constructor.
- Parameters
fitter – The vertex fitter
sfinder – The seed finder
ipEst – ImpactPointEstimator
lin – Track linearizer
bIn – Input magnetic field
Public Members
-
bool addSingleTrackVertices = false
-
std::shared_ptr<const MagneticFieldProvider> bField
-
std::pair<double, double> defaultConstrFitQuality = {0., -3.}
-
bool do3dSplitting = false
-
bool doRealMultiVertex = true
-
ImpactPointEstimator<InputTrack_t, Propagator_t> ipEstimator
-
Linearizer_t linearizer
-
double looseConstrValue = 1e+8
-
double maximumVertexContamination = 0.5
-
int maxIterations = 100
-
double maxMergeVertexSignificance = 3.
-
double maxVertexChi2 = 18.42
-
double minWeight = 0.0001
-
sfinder_t seedFinder
-
double tracksMaxSignificance = 5.
-
double tracksMaxZinterval = 3. * Acts::UnitConstants::mm
-
bool useBeamSpotConstraint = true
-
bool useFastCompatibility = true
-
bool useSeedConstraint = true
-
bool useVertexCovForIPEstimation = false
-
vfitter_t vertexFitter
-
struct State
- #include <Acts/Vertexing/AdaptiveMultiVertexFinder.hpp>
State struct for fulfilling interface.
-
template<typename input_track_t, typename linearizer_t>
class AdaptiveMultiVertexFitter - #include <Acts/Vertexing/AdaptiveMultiVertexFitter.hpp>
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
- Template Parameters
input_track_t – Track object type
linearizer_t – Track linearizer type
Public Types
-
using InputTrack_t = input_track_t
-
using Linearizer_t = linearizer_t
-
using Propagator_t = typename linearizer_t::Propagator_t
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline AdaptiveMultiVertexFitter(Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("AdaptiveMultiVertexFitter", Logging::INFO)) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
logger – The logging instance
-
inline AdaptiveMultiVertexFitter(Config &cfg, std::function<BoundTrackParameters(InputTrack_t)> func, std::unique_ptr<const Logger> logger = getDefaultLogger("AdaptiveMultiVertexFitter", Logging::INFO))
Constructor for user-defined InputTrack_t type != BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
logger – The logging instance
-
Result<void> addVtxToFit(State &state, Vertex<InputTrack_t> &newVertex, const Linearizer_t &linearizer, const VertexingOptions<InputTrack_t> &vertexingOptions) const
Adds new vertex to an existing multi-vertex fit and fits everything together (by invoking the fit_impl method):
The new vertex is added to the fit: all associated tracks get initialized, i.e. ParamsAtIP3d are created (from ImpactPointEstimator) to be later able to estimate in a fast way the compatibility of the tracks to their respective vertices.
All tracks belonging to the new vertex are scanned and all the vertices which share tracks with the new vertex to be fit are also added to the fit.
The multivertex fit is performed with all involved vertices.
This has the advantage that only vertices that are affected by adding the new vertex are refitted.
Note: newVertex has to be properly initialized (seed vertex, constraint vertex, list of MAV)
- Parameters
state – The state object
newVertex – New vertex to be added to fit
linearizer – The track linearizer
vertexingOptions – Vertexing options
- Returns
Result<void> object
-
Result<void> fit(State &state, const std::vector<Vertex<InputTrack_t>*> &verticesToFit, const Linearizer_t &linearizer, const VertexingOptions<InputTrack_t> &vertexingOptions) const
The actual fit function, performs a simultaneous fit of all vertices in
verticesToFit
by invokingfitImpl
- Parameters
state – The state object
verticesToFit – Vector containing all vertices to be fitted
linearizer – The track linearizer
vertexingOptions – Vertexing options
- Returns
Result<void> object
-
struct Config
- #include <Acts/Vertexing/AdaptiveMultiVertexFitter.hpp>
Public Functions
-
inline Config(const IPEstimator &est)
Config constructor.
- Parameters
est – ImpactPointEstimator
Public Members
-
AnnealingUtility annealingTool
Annealing tool used for a thermodynamic annealing scheme for the track weight factors in such a way that with high temperature values (at the beginning) only a slight preference is given to tracks compatible with the estimated vertex position.
With lower temperatures the weighting get stricter such that all incompatible tracks will be dropped at the end while keeping all compatible tracks with a weight=1. 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
-
bool doSmoothing = {false}
-
IPEstimator ipEst
-
double maxDistToLinPoint = {0.5}
-
unsigned int maxIterations = {30}
-
double maxRelativeShift = {0.01}
-
double minWeight = {0.0001}
-
inline Config(const IPEstimator &est)
-
struct State
- #include <Acts/Vertexing/AdaptiveMultiVertexFitter.hpp>
The fitter state.
Public Functions
-
inline State(const MagneticFieldProvider &field, const Acts::MagneticFieldContext &magContext)
-
State() = default
Default State constructor.
-
inline void addVertexToMultiMap(Vertex<InputTrack_t> &vtx)
-
inline void removeVertexFromMultiMap(Vertex<InputTrack_t> &vtx)
Public Members
-
AnnealingUtility::State annealingState
-
IPEstimator::State ipState
-
Linearizer_t::State linearizerState
-
std::map<std::pair<const InputTrack_t*, Vertex<InputTrack_t>*>, TrackAtVertex<InputTrack_t>> tracksAtVerticesMap
-
std::multimap<const InputTrack_t*, Vertex<InputTrack_t>*> trackToVerticesMultiMap
-
std::vector<Vertex<InputTrack_t>*> vertexCollection
-
std::map<Vertex<InputTrack_t>*, VertexInfo<InputTrack_t>> vtxInfoMap
-
inline State(const MagneticFieldProvider &field, const Acts::MagneticFieldContext &magContext)
-
class AnnealingUtility
- #include <Acts/Utilities/AnnealingUtility.hpp>
Implements a deterministic thermodynamic annealing scheme Ref.
(1): CERN-THESIS-2010-027
Public Functions
-
void anneal(State &state) const
Does the actual annealing step.
-
double getWeight(State &state, double chi2, const std::vector<double> &allChi2) const
Weight access.
- Parameters
state – The state object
chi2 – Chi^2 for e.g. current track, i.e. compatibility of track to current vertex candidate
allChi2 – Vector of all chi^2 values, i.e. e.g. compatibilities of current track to all vertices it is currently attached to
- Returns
Calculated weight according to Eq.(5.46) in Ref.(1)
-
double getWeight(State &state, double chi2) const
Weight access.
- Parameters
state – The state object
chi2 – Chi^2
- Returns
Calculated weight
-
struct Config
- #include <Acts/Utilities/AnnealingUtility.hpp>
The configuration struct.
Public Functions
-
inline Config(const std::vector<double> &temperatures = {64., 16., 4., 2., 1.5, 1.})
Public Members
-
double cutOff = {9.}
-
std::vector<double> setOfTemperatures
-
inline Config(const std::vector<double> &temperatures = {64., 16., 4., 2., 1.5, 1.})
-
struct State
- #include <Acts/Utilities/AnnealingUtility.hpp>
The annealing state Resetting the state is done by just creating a new instance.
Public Members
-
unsigned int currentTemperatureIndex = {0}
-
bool equilibriumReached = {false}
-
unsigned int currentTemperatureIndex = {0}
-
void anneal(State &state) const
-
class AnnulusBounds : public Acts::DiscBounds
- #include <Acts/Surfaces/AnnulusBounds.hpp>
Class that implements a (potentially asymmetric) bounds with difference between surface bound center and surface coordinate center.
These bounds combine two different systems:
module system : radial bounds centred on the moduleOrigin
strip system : phi bounds centred on the stripOrigin
The measurement will be done in the strip system, with r/phi local coordinates.
Public Types
-
enum BoundValues
Values:
-
enumerator eMinR
-
enumerator eMaxR
-
enumerator eMinPhiRel
-
enumerator eMaxPhiRel
-
enumerator eAveragePhi
-
enumerator eOriginX
-
enumerator eOriginY
-
enumerator eSize
-
enumerator eMinR
Public Functions
-
AnnulusBounds() = delete
-
inline AnnulusBounds(double minR, double maxR, double minPhiRel, double maxPhiRel, const Vector2 &moduleOrigin = {0, 0}, double avgPhi = 0) noexcept(false)
Default constructor from parameters.
Note
For
morigin
you need to actually calculate the cartesian offset- Parameters
minR – inner radius, in module system
maxR – outer radius, in module system
minPhiRel – right angular edge, in strip system, rel to avgPhi
maxPhiRel – left angular edge, in strip system, rel to avgPhi
moduleOrigin – The origin offset between the two systems.
avgPhi – (Optional) internal rotation of this bounds object’s local frame
-
AnnulusBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from parameters array.
- Parameters
values – The parameter array
-
AnnulusBounds(const AnnulusBounds &source) = default
-
inline virtual double binningValuePhi() const final
Return a reference radius for binning.
-
inline virtual double binningValueR() const final
Return a reference radius for binning.
-
std::vector<Vector2> corners() const
This method returns the four corners of the bounds in polar coordinates Starting from the upper right (max R, pos locX) and proceding clock-wise i.e.
(max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R: neg locX)
-
inline virtual bool coversFullAzimuth() const final
Returns true for full phi coverage.
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
inline virtual bool insideRadialBounds(double R, double tolerance = 0.) const final
Checks if this is inside the radial coverage given the a tolerance.
-
Vector2 moduleOrigin() const
Returns moduleOrigin, but rotated out, so
averagePhi
is already considered.The module origin needs to consider the rotation introduced by
averagePhi
- Returns
The origin of the local frame
-
inline double phiMax() const
Returns the left angular edge of the module.
- Returns
The left side angle
-
inline double phiMin() const
Returns the right angular edge of the module.
- Returns
The right side angle
-
inline virtual double rMax() const final
This method returns outer radius.
-
inline virtual double rMin() const final
This method returns inner radius.
-
virtual std::ostream &toStream(std::ostream &sl) const final
Outstream operator.
- Parameters
sl – is the ostream to be dumped into
-
inline virtual SurfaceBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
virtual std::vector<Vector2> vertices(unsigned int lseg) const
This method returns the xy coordinates of the four corners of the bounds in module coorindates (in x/y) Starting from the upper right (max R, pos locX) and proceding clock-wise i.e.
(max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R: neg locX)
Note
that that if
lseg
> 0, the extrema points are given, which may slightly alter the number of segments returned- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
class AnyCharge
- #include <Acts/EventData/Charge.hpp>
Charge and momentum interpretation for arbitrarily charged particles.
Only a charge magnitude identical to zero is interpreted as representing a neutral particle. This avoids ambiguities that might arise from using an approximate comparison with an arbitrary epsilon.
Public Functions
-
AnyCharge() = delete
Delete default constructor to ensure charge is always explicitely given.
-
template<typename T>
inline constexpr AnyCharge(T absQ) noexcept Construct with the magnitude of the input charge.
-
AnyCharge() = delete
-
class ApproachDescriptor
- #include <Acts/Geometry/ApproachDescriptor.hpp>
Virtual base class to decide and return which approaching surface to be taken, the surfaces are std::shared_ptr, as they can be the boundary surfaces of the representingVolume of the Layer.
Subclassed by Acts::GenericApproachDescriptor
Public Functions
-
ApproachDescriptor() = default
-
virtual ~ApproachDescriptor() = default
-
virtual ObjectIntersection<Surface> approachSurface(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck) const = 0
Get the surface on approach.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the position from start of the search
direction – is the direction at the start of the search
bcheck – is the boundary check directive
- Returns
is a surface intersection
-
virtual const std::vector<const Surface*> &containedSurfaces() const = 0
Get all the contained surfaces.
- Returns
all contained surfaces of this approach descriptor
-
virtual std::vector<const Surface*> &containedSurfaces() = 0
Non-const version.
-
virtual void registerLayer(const Layer &lay) = 0
Register Layer Links the layer to the approach surfaces.
- Parameters
lay – is the layer to be assigned
-
ApproachDescriptor() = default
-
class AssertionFailureException : public std::exception
- #include <Acts/Utilities/ThrowAssert.hpp>
Exception type for assertion failures This class captures the information available to the throw_assert macro.
Public Functions
-
inline AssertionFailureException(const std::string &expression, const std::string &file, int line, const std::string &msg)
Construct an assertion failure exception, captures macro info.
- Parameters
expression – The expression being asserted
file – The current file
line – The current line
msg – The message to print if assertion fails
-
inline const char *what() const override
The assertion message.
-
class StreamFormatter
- #include <Acts/Utilities/ThrowAssert.hpp>
Class which allows to use the << operator to assemble a string.
Public Functions
-
template<typename T>
inline StreamFormatter &operator<<(const T &value) Stream operator which takes everything and forwards it to the stringstream.
- Template Parameters
T – type of anything
- Parameters
value – const ref to anything
-
template<typename T>
-
inline AssertionFailureException(const std::string &expression, const std::string &file, int line, const std::string &msg)
-
class AtlasStepper
- #include <Acts/Propagator/AtlasStepper.hpp>
the AtlasStepper implementation for the
Public Types
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
using Covariance = BoundSymMatrix
-
using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>
-
using Jacobian = BoundMatrix
Public Functions
-
inline Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Create and return the bound state at the current position.
- Parameters
state – [in] State that will be presented as
BoundState
surface – [in] The surface to which we bind the state
transportCov – [in] Flag steering covariance transport
freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound
- Returns
A bound state:
the parameters at the surface
the stepwise jacobian towards it
and the path length (from start - for ordering)
-
inline double charge(const State &state) const
Charge access.
-
inline CurvilinearState curvilinearState(State &state, bool transportCov = true) const
Create and return a curvilinear state at the current position.
- Parameters
state – [in] State that will be presented as
CurvilinearState
transportCov – [in] Flag steering covariance transport
- Returns
A curvilinear state:
the curvilinear parameters at given position
the stepweise jacobian towards it
and the path length (from start - for ordering)
-
inline Result<Vector3> getField(State &state, const Vector3 &pos) const
Get the field for the stepping It checks first if the access is still within the Cell, and updates the cell if necessary, then it takes the field from the cell.
- Parameters
state – [inout] is the stepper state associated with the track the magnetic field cell is used (and potentially updated)
pos – [in] is the field position
-
inline double getStepSize(const State &state, ConstrainedStep::Type stype) const
Get the step size.
- Parameters
state – [in] The stepping state (thread-local cache)
stype – [in] The step size type to be returned
-
inline double momentum(const State &state) const
-
inline std::string outputStepSize(const State &state) const
Output the Step Size - single component.
- Parameters
state – [inout] The stepping state (thread-local cache)
-
inline double overstepLimit(const State&) const
Overstep limit.
-
inline void releaseStepSize(State &state) const
Release the Step size.
- Parameters
state – [inout] The stepping state (thread-local cache)
Resets the state.
- Parameters
state – [inout] State of the stepper
boundParams – [in] Parameters in bound parametrisation
cov – [in] Covariance matrix
surface – [in] Reset state will be on this surface
navDir – [in] Navigation direction
stepSize – [in] Step size
-
inline void setIdentityJacobian(State &state) const
Method that reset the Jacobian to the Identity for when no bound state are available.
- Parameters
state – [inout] State of the stepper
-
inline void setStepSize(State &state, double stepSize, ConstrainedStep::Type stype = ConstrainedStep::actor, bool release = true) const
Set Step size - explicitely with a double.
- Parameters
state – [inout] The stepping state (thread-local cache)
stepSize – [in] The step size value
stype – [in] The step size type to be set
release – [in] Do we release the step size?
-
template<typename propagator_state_t>
inline Result<double> step(propagator_state_t &state) const Perform the actual step on the state.
- Parameters
state – is the provided stepper state (caller keeps thread locality)
-
inline double time(const State &state) const
Time access.
-
inline void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection& = FreeToBoundCorrection(false)) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
- Parameters
state – [inout] State of the stepper
surface – [in] is the surface to which the covariance is forwarded to
-
inline void transportCovarianceToCurvilinear(State &state) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
- Parameters
state – [inout] State of the stepper
-
inline void update(State &state, const FreeVector ¶meters, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const
The state update method.
- Parameters
state – [inout] The stepper state for
parameters – [in] The new free track parameters at start
boundParams – [in] Corresponding bound parameters
covariance – [in] The updated covariance matrix
surface – [in] The surface used to update the pVector
-
inline void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double up, double time) const
Method to update momentum, direction and p.
- Parameters
state – The state object
uposition – the updated position
udirection – the updated direction
up – the updated momentum value
time – the update time
-
template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, bool release = true) const Update step size.
It checks the status to the reference surface & updates the step size accordingly
- Parameters
state – [in,out] The stepping state (thread-local cache)
oIntersection – [in] The ObjectIntersection to layer, boundary, etc
release – [in] boolean to trigger step size release
-
inline Intersection3D::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck, LoggerWrapper logger = getDummyLogger()) const
Update surface status.
This method intersect the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.
- Parameters
state – [inout] The stepping state (thread-local cache)
surface – [in] The surface provided
bcheck – [in] The boundary check for this status update
logger – [in] Logger instance to use
-
struct State
- #include <Acts/Propagator/AtlasStepper.hpp>
Nested State struct for the local caching.
Public Functions
-
State() = delete
Default constructor - deleted.
Constructor.
- Template Parameters
Type – of TrackParameters
- Parameters
gctx – [in] The geometry contex tof this call
fieldCacheIn – [in] The magnetic field cache for this call
pars – [in] Input parameters
ndir – [in] The navigation direction w.r.t. parameters
ssize – [in] the steps size limitation
stolerance – [in] is the stepping tolerance
Public Members
-
Covariance cov = Covariance::Zero()
-
const Covariance *covariance
-
bool covTransport = false
-
bool debug = false
Debug output the string where debug messages are stored (optionally)
-
size_t debugMsgWidth = 50
-
size_t debugPfxWidth = 30
buffer & formatting for consistent output
-
std::string debugString = ""
-
Vector3 field
-
MagneticFieldProvider::Cache fieldCache
It caches the current magnetic field cell and stays (and interpolates) within as long as this is valid.
See step() code for details.
-
std::reference_wrapper<const GeometryContext> geoContext
Cache the geometry context.
-
double jacobian[eBoundSize * eBoundSize]
-
double maxPathLength
-
bool mcondition
-
bool needgradient
-
bool newfield
-
double parameters[eBoundSize] = {0., 0., 0., 0., 0., 0.}
Storage pattern of pVector /dL0 /dL1 /dPhi /dThe /dCM /dT X ->P[0] dX / P[ 8] P[16] P[24] P[32] P[40] P[48] Y ->P[1] dY / P[ 9] P[17] P[25] P[33] P[41] P[49] Z ->P[2] dZ / P[10] P[18] P[26] P[34] P[42] P[50] T ->P[3] dT/ P[11] P[19] P[27] P[35] P[43] P[51] Ax ->P[4] dAx/ P[12] P[20] P[28] P[36] P[44] P[52] Ay ->P[5] dAy/ P[13] P[21] P[29] P[37] P[45] P[53] Az ->P[6] dAz/ P[14] P[22] P[30] P[38] P[46] P[54] CM ->P[7] dCM/ P[15] P[23] P[31] P[39] P[47] P[55] Cache: P[56] - P[59].
-
double pathAccumulated = 0.
-
double previousStepSize = 0.
-
std::array<double, 60> pVector
-
bool state_ready = false
-
double step
-
ConstrainedStep stepSize
-
double tolerance = s_onSurfaceTolerance
The tolerance for the stepping.
-
bool useJacobian
-
State() = delete
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
template<template<typename> typename basic_extension_t>
struct AutodiffExtensionWrapper - #include </home/docs/checkouts/readthedocs.org/user_builds/acts/checkouts/v20.2.0/Plugins/Autodiff/include/Acts/Plugins/Autodiff/AutodiffExtensionWrapper.hpp>
Default RKN4 evaluator for autodiff.
Public Types
-
using AutodiffFreeMatrix = Eigen::Matrix<AutodiffScalar, eFreeSize, eFreeSize>
-
using AutodiffFreeVector = Eigen::Matrix<AutodiffScalar, eFreeSize, 1>
-
using AutodiffScalar = autodiff::dual
-
using AutodiffVector3 = Eigen::Matrix<AutodiffScalar, 3, 1>
Public Functions
-
AutodiffExtensionWrapper() = default
Default constructor.
-
template<typename propagator_state_t, typename stepper_t>
inline int bid(const propagator_state_t &ps, const stepper_t &st) const
-
template<typename propagator_state_t, typename stepper_t>
inline bool finalize(propagator_state_t &state, const stepper_t &stepper, const double h) const
-
template<typename propagator_state_t, typename stepper_t>
inline bool finalize(propagator_state_t &state, const stepper_t &stepper, const double h, FreeMatrix &D) const
Public Members
-
basic_extension_t<double> m_doubleExtension
-
using AutodiffFreeMatrix = Eigen::Matrix<AutodiffScalar, eFreeSize, eFreeSize>
-
template<typename entity_t, typename value_t, size_t DIM>
class AxisAlignedBoundingBox - #include <Acts/Utilities/BoundingBox.hpp>
Implementation of an Axis Aligned Bounding Box.
This type is compatible with 2D and 3D boxes
Public Types
-
using entity_type = entity_t
Type of stored entity.
-
using Size = NamedType<VertexType, struct SizeParameter>
Strong type to select the correct constructor.
-
using transform_type = Eigen::Transform<value_type, DIM, Eigen::Affine>
The transform type based on the
value_type
-
using value_type = value_t
The value type used by this class.
Public Functions
-
AxisAlignedBoundingBox(const self_t &other) = default
Copy constructor from other bounding box.
- Parameters
other – The other AABB
-
AxisAlignedBoundingBox(const entity_t *entity, const VertexType &vmin, const VertexType &vmax)
Constructor from an entity pointer, and the min and max vertices.
- Parameters
entity – The entity to store
vmin – The minimum vertex.
vmax – The maximum vertex.
-
AxisAlignedBoundingBox(const entity_t *entity, const VertexType ¢er, const Size &size)
Constructor from a center position, and a width and height.
Note
The special type
size
is required to disambiguate this constructor from the other one above. It is a wrapper around a simpleVector3
.- Parameters
entity – The entity to store
center – The center position
size – The size (width and height) of the box.
-
AxisAlignedBoundingBox(const std::vector<self_t*> &boxes, vertex_array_type envelope = vertex_array_type::Zero())
Constructor from a list of child boxes.
This box will wrap around all boxes contained in
boxes
, and additional envelope can be given.- Parameters
boxes – Vector of child boxes to store in this bounding box.
envelope – Envelope that will be added/subtracted to the dimension.
-
const VertexType ¢er() const
Get the center position of this bounding box.
- Returns
The center position
-
template<size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
void draw(IVisualization3D &helper, std::array<int, 3> color = {120, 120, 120}, const transform_type &trf = transform_type::Identity()) const Draw this bounding box using the given visualization helper.
This method is only available for the 3D case.
- Template Parameters
D – (used for SFINAE)
- Parameters
helper – The visualization helper to write to
color – The color to use for drawing
trf – An optional transform to apply first.
-
const entity_t *entity() const
Return the entity associated with this box.
This might be nullptr if there is no entity attached.
- Returns
The entity pointer, might be nullptr
-
const self_t *getLeftChild() const
Get the left child (i.e.
the first of the children that are inside this bounding box).
- Returns
The lest most child.
-
const self_t *getSkip() const
Get the skip node for this box.
- Returns
The skip node pointer
-
bool hasEntity() const
Check whether this node as an associated entity.
If it does not have one, this is a purely abstract container box.
- Returns
Whether the box has an entity attached.
-
bool intersect(const VertexType &point) const
Calculate whether a point is inside this box.
- Parameters
point – The point to test.
- Returns
Whether the point is inside or not.
-
bool intersect(const Ray<value_type, DIM> &ray) const
Implements the slab method for Ray/AABB intersections.
See https://tavianator.com/fast-branchless-raybounding-box-intersections/, https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/, https://medium.com/@bromanz/another-view-on-the-classic-ray-aabb-intersection-algorithm-for-bvh-traversal-41125138b525 The original algorithms is described in “Graphics Gems (1990)” 1
Note
This implementation may treat parallel rays on any of the slabs as outside due to how
NaNs
are handled by Eigen. See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=564- Parameters
ray – The ray to intersect with
- Returns
Whether the ray intersects this AABB
-
template<size_t sides>
bool intersect(const Frustum<value_type, DIM, sides> &fr) const Check if a frustum intersects with this bounding box.
This method implements an algorithm similar to the one described in “Optimized View Frustum Culling Algorithms for Bounding Boxes (2012)” 2, but drops some of the more sophisticated optimization.
- Parameters
fr – The frustum
- Returns
Whether the frustum intersects this AABB
-
const VertexType &max() const
Get the maximum vertex.
- Returns
The maximum vertex
-
const VertexType &min() const
Get the minimum vertex.
- Returns
The minimum vertex
-
AxisAlignedBoundingBox &operator=(const self_t &other) = default
Copy assignment operator from other bounding box.
- Parameters
other – The other AABB
-
void setEntity(const entity_t *entity)
Set the entity associated with with this box.
- Parameters
entity – The entity
-
void setSkip(self_t *skip)
Set the skip node (bounding box)
- Parameters
skip – The target skip node pointer
-
template<size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
std::ostream &svg(std::ostream &os, value_type w, value_type h, value_type unit = 10, std::string label = "", std::string fillcolor = "grey") const Draw this bounding box as SVG.
This method is only available for the 2D case.
- Template Parameters
D – (used for SFINAE)
- Parameters
os – The output stream to write to
w – The width of the output SVG.
h – The height of the output SVG.
unit – A scale factor to apply before drawing
label – A label to put next to the box.
fillcolor – Color to fill the box with.
- Returns
The outstream given in
os
.
-
std::ostream &toStream(std::ostream &os) const
Write information about this bounding box to a stream.
- Parameters
os – The output stream.
- Returns
The stream given as an argument.
-
void transform(const transform_type &trf)
Transforms this bounding box using the given transform.
This method modifies the box it is called on.
- Parameters
trf – The transform
-
self_t transformed(const transform_type &trf) const
Transforms this bounding box using the given transfom.
This method returns a copy of this box, with the transformation applied, and leaves this instance unchanged.
- Parameters
trf – The transform
- Returns
The transformed bounding box
Public Static Functions
-
static std::pair<VertexType, VertexType> wrap(const std::vector<const self_t*> &boxes, vertex_array_type envelope = vertex_array_type::Zero())
Helper function to calculate the size of a bounding box enclosing
boxes
.- Parameters
boxes – The boxes to wrap (const pointers)
envelope – Optional envelop to add/subtract to dimension.
- Returns
Pair of vertixes: min and max.
-
static std::pair<VertexType, VertexType> wrap(const std::vector<self_t*> &boxes, vertex_array_type envelope = vertex_array_type::Zero())
Helper function to calculate the size of a bounding box enclosing
boxes
.Overload which accepts non-const boxes in
boxes
.- Parameters
boxes – The boxes to wrap (non-const pointers)
envelope – Optional envelop to add/subtract to dimension.
- Returns
Pair of vertixes: min and max.
-
static std::pair<VertexType, VertexType> wrap(const std::vector<self_t> &boxes, vertex_array_type envelope = vertex_array_type::Zero())
Helper function to calculate the size of a bounding box enclosing
boxes
.Overload which accepts a vector in
boxes
which owns the instances- Parameters
boxes – The boxes to wrap (by-value vector)
envelope – Optional envelop to add/subtract to dimension.
- Returns
Pair of vertixes: min and max.
Public Static Attributes
-
static const size_t dim = DIM
Re-export dimension from template parameter.
-
using entity_type = entity_t
-
template<typename external_spacepoint_t>
class BinFinder - #include <Acts/Seeding/BinFinder.hpp>
The BinFinder is used by the ISPGroupSelector.
It can be used to find both bins that could be bottom bins as well as bins that could be top bins, which are assumed to be the same bins. Does not take interaction region into account to limit z-bins.
Public Functions
-
BinFinder()
constructor
-
BinFinder(const std::vector<std::pair<int, int>> &&zBinNeighbors, const int &&numPhiNeighbors)
-
BinFinder(const std::vector<std::pair<int, int>> &zBinNeighbors, const int &numPhiNeighbors)
-
~BinFinder() = default
destructor
-
boost::container::small_vector<size_t, 10> findBins(size_t phiBin, size_t zBin, const SpacePointGrid<external_spacepoint_t> *binnedSP)
Return all bins that could contain space points that can be used with the space points in the bin with the provided indices to create seeds.
- Parameters
phiBin – phi index of bin with middle space points
zBin – z index of bin with middle space points
binnedSP – phi-z grid containing all bins
-
BinFinder()
-
template<class T>
class BinnedArray - #include <Acts/Utilities/BinnedArray.hpp>
Pure virtual base class for Binned Array to avoid map searches.
there is only one restriction: T must be of pointer type in order to be initialized withh nullptr and to allow for nullptr return type
the BinnedArray is designed for 0D, 1D, 2D, and 3D binning
Subclassed by Acts::BinnedArrayXD< T >
Public Functions
-
BinnedArray() = default
Default Constructor - needed for inherited classes.
-
virtual ~BinnedArray() = default
Virtual Destructor.
-
virtual const std::vector<T> &arrayObjects() const = 0
Return all unqiue object.
Note
this is the accessor to the
- Returns
the vector of all array objects
-
virtual const BinUtility *binUtility() const = 0
Return the BinUtility.
if returned 0 it is a 0D array
- Returns
plain pointer to the bin utility
-
virtual T object(const Vector2 &lposition, std::array<size_t, 3> &bins) const = 0
Returns the object in the associated bin according the local position.
- Parameters
lposition – is the local position for the object retrieval
bins – is the bin triple to filled
- Returns
the object according to the estimated bin
-
inline virtual T object(const Vector2 &lposition) const
Same method without bins for backward compatibility.
- Parameters
lposition – is the local position for finding the obect
- Returns
the object according to the estimated bin
-
virtual T object(const Vector3 &position, std::array<size_t, 3> &bin) const = 0
Returns the object in the associated bin according the local position.
- Parameters
position – is the global position for the object retrieval
bin – is the bin triple filled
- Returns
the object according to the estimated bin
-
inline virtual T object(const Vector3 &position) const
Same method without bins for backward compatibility.
- Parameters
position – is the global position for the object finding
- Returns
the object according to the estimated bin
-
virtual const std::vector<std::vector<std::vector<T>>> &objectGrid() const = 0
Return the object grid multiple entries are allowed.
- Returns
the object grid
-
template<class T>
class BinnedArrayXD : public Acts::BinnedArray<T> - #include <Acts/Utilities/BinnedArrayXD.hpp>
Avoiding a map search, the templated BinnedArray class can help ordereing geometrical objects by providing a dedicated BinUtility.
This can be 0D, 1D, 2D, and 3D in regular binning
the type of Binning is given defined through the BinUtility
Public Functions
-
inline BinnedArrayXD(T object)
Constructor for single object.
- Template Parameters
object – is the single object
-
inline BinnedArrayXD(const std::vector<TAP> &tapvector, std::unique_ptr<const BinUtility> bu)
Constructor with std::vector and a BinUtility.
fills the internal data structur
- Parameters
tapvector – is a vector of object and binning position
bu – is the unique bin utility for this binned array
-
inline BinnedArrayXD(const std::vector<std::vector<std::vector<T>>> &grid, std::unique_ptr<const BinUtility> bu)
Constructor with a grid and a BinUtility.
- Parameters
grid – is the prepared object grid
bu – is the unique bin utility for this binned array
-
BinnedArrayXD(const BinnedArrayXD<T> &barr) = delete
Copy constructor.
not allowed, use the same array
-
~BinnedArrayXD() override = default
Destructor.
-
inline virtual const std::vector<T> &arrayObjects() const final
Return all unqiue object.
- Returns
vector of unique array objects
-
inline virtual const BinUtility *binUtility() const final
Return the BinUtility.
- Returns
plain pointer to the bin utility of this array
-
inline virtual T object(const Vector2 &lposition, std::array<size_t, 3> &bins) const final
Returns the object in the array from a local position.
- Parameters
lposition – is the local position for the bin search
bins – is the bin triple filled during this access
- Returns
is the object in that bin
-
inline virtual T object(const Vector2 &lposition) const override
Same method without bins for backward compatibility.
- Parameters
lposition – is the local position for finding the obect
- Returns
the object according to the estimated bin
-
inline virtual T object(const Vector3 &position, std::array<size_t, 3> &bins) const final
Returns the object in the array from a global position.
- Parameters
position – is the global position for the bin search
bins – is the bins triple filled during access
- Returns
is the object in that bin
-
inline virtual T object(const Vector3 &position) const override
Same method without bins for backward compatibility.
- Parameters
position – is the global position for the object finding
- Returns
the object according to the estimated bin
-
inline virtual const std::vector<std::vector<std::vector<T>>> &objectGrid() const final
Return the object grid multiple entries are allowed and wanted.
- Returns
internal object grid
-
BinnedArrayXD &operator=(const BinnedArrayXD<T> &barr) = delete
Assignment operator.
not allowed, use the same array
-
inline BinnedArrayXD(T object)
-
template<typename external_spacepoint_t>
class BinnedSPGroup - #include <Acts/Seeding/BinnedSPGroup.hpp>
BinnedSPGroup
Provides access to begin and end BinnedSPGroupIterator for given BinFinders and SpacePointGrid.Fulfills the range_expression interface.
Public Functions
-
BinnedSPGroup() = delete
-
inline BinnedSPGroupIterator<external_spacepoint_t> begin()
-
inline BinnedSPGroupIterator<external_spacepoint_t> end()
-
inline size_t size()
-
BinnedSPGroup() = delete
-
template<typename external_spacepoint_t>
class BinnedSPGroupIterator - #include <Acts/Seeding/BinnedSPGroup.hpp>
BinnedSPGroupIterator
Allows to iterate over all groups of bins a provided BinFinder can generate for each bin of a provided SPGridPublic Functions
-
inline BinnedSPGroupIterator(const SpacePointGrid<external_spacepoint_t> *spgrid, BinFinder<external_spacepoint_t> *botBinFinder, BinFinder<external_spacepoint_t> *tBinFinder, std::vector<size_t> bins = {})
-
inline BinnedSPGroupIterator(const SpacePointGrid<external_spacepoint_t> *spgrid, BinFinder<external_spacepoint_t> *botBinFinder, BinFinder<external_spacepoint_t> *tBinFinder, size_t phiInd, size_t zInd, std::vector<size_t> bins = {})
-
inline Neighborhood<external_spacepoint_t> bottom()
-
inline Neighborhood<external_spacepoint_t> middle()
-
inline bool operator!=(const BinnedSPGroupIterator &otherState)
-
inline BinnedSPGroupIterator &operator++()
-
inline bool operator==(const BinnedSPGroupIterator &otherState)
-
inline Neighborhood<external_spacepoint_t> top()
-
inline BinnedSPGroupIterator(const SpacePointGrid<external_spacepoint_t> *spgrid, BinFinder<external_spacepoint_t> *botBinFinder, BinFinder<external_spacepoint_t> *tBinFinder, std::vector<size_t> bins = {})
-
class BinnedSurfaceMaterial : public Acts::ISurfaceMaterial
- #include <Acts/Material/BinnedSurfaceMaterial.hpp>
It extends the
ISurfaceMaterial
base class and is an array pf MaterialSlab.This is not memory optimised as every bin holds one material property object.
Public Functions
-
BinnedSurfaceMaterial() = delete
Default Constructor - deleted.
-
BinnedSurfaceMaterial(const BinUtility &binUtility, MaterialSlabVector fullProperties, double splitFactor = 0., MappingType mappingType = MappingType::Default)
Explicit constructor with only full MaterialSlab, for one-dimensional binning.
The split factors:
1. : oppositePre
0. : alongPre ===> 1 Dimensional array
- Parameters
binUtility – defines the binning structure on the surface (copied)
fullProperties – is the vector of properties as recorded (moved)
splitFactor – is the pre/post splitting directive
mappingType – is the type of surface mapping associated to the surface
-
BinnedSurfaceMaterial(const BinUtility &binUtility, MaterialSlabMatrix fullProperties, double splitFactor = 0., MappingType mappingType = MappingType::Default)
Explicit constructor with only full MaterialSlab, for two-dimensional binning.
The split factors:
1. : oppositePre
0. : alongPre ===> 1 Dimensional array
- Parameters
binUtility – defines the binning structure on the surface (copied)
fullProperties – is the vector of properties as recorded (moved)
splitFactor – is the pre/post splitting directive
mappingType – is the type of surface mapping associated to the surface
-
BinnedSurfaceMaterial(BinnedSurfaceMaterial &&bsm) = default
Copy Move Constructor.
- Parameters
bsm – is the source object to be copied
-
BinnedSurfaceMaterial(const BinnedSurfaceMaterial &bsm) = default
Copy Constructor.
- Parameters
bsm – is the source object to be copied
-
~BinnedSurfaceMaterial() override = default
Destructor.
-
inline const BinUtility &binUtility() const
Return the BinUtility.
-
inline const MaterialSlabMatrix &fullMaterial() const
Retrieve the entire material slab matrix.
-
virtual const MaterialSlab &materialSlab(const Vector2 &lp) const final
Return method for full material description of the Surface.
from local coordinate on the surface
- Parameters
lp – is the local position used for the (eventual) lookup
- Returns
const MaterialSlab
-
virtual const MaterialSlab &materialSlab(const Vector3 &gp) const final
Return method for full material description of the Surface.
from the global coordinates
- Parameters
gp – is the global position used for the (eventual) lookup
- Returns
const MaterialSlab
-
inline virtual const MaterialSlab &materialSlab(size_t bin0, size_t bin1) const final
Direct access via bins to the MaterialSlab.
- Parameters
bin0 – is the material bin in dimension 0
bin1 – is the material bin in dimension 1
-
virtual BinnedSurfaceMaterial &operator*=(double scale) final
Scale operator.
- Parameters
scale – is the scale factor for the full material
-
BinnedSurfaceMaterial &operator=(BinnedSurfaceMaterial &&bsm) = default
Assignment Move operator.
-
BinnedSurfaceMaterial &operator=(const BinnedSurfaceMaterial &bsm) = default
Assignment operator.
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream, to be overloaded by child classes.
-
BinnedSurfaceMaterial() = delete
-
class BinningData
- #include <Acts/Utilities/BinningData.hpp>
This class holds all the data necessary for the bin calculation.
phi has a very particular behaviour:
there’s the change around +/- PI
it can be multiplicative or additive multiplicative : each major bin has the same sub structure i.e. first binnning
structure is equidistant additive : sub structure replaces one bin (and one bin only)
Public Functions
-
inline BinningData(BinningValue bValue, float bMin, float bMax)
Constructor for 0D binning.
- Parameters
bValue – is the binning value: binX, binY, etc.
bMin – is the minum value
bMax – is the maxmimum value
-
inline BinningData(BinningOption bOption, BinningValue bValue, size_t bBins, float bMin, float bMax, std::unique_ptr<const BinningData> sBinData = nullptr, bool sBinAdditive = false)
Constructor for equidistant binning and optional sub structure can be mulitplicative or additive.
- Parameters
bOption – is the binning option : open, closed
bValue – is the binning value: binX, binY, etc.
bBins – is number of equidistant bins
bMin – is the minum value
bMax – is the maxmimum value
sBinData – is (optional) sub structure
sBinAdditive – is the prescription for the sub structure
-
inline BinningData(BinningOption bOption, BinningValue bValue, const std::vector<float> &bBoundaries, std::unique_ptr<const BinningData> sBinData = nullptr)
Constructor for non-equidistant binning.
- Parameters
bOption – is the binning option : open / closed
bValue – is the binning value : binX, binY, etc.
bBoundaries – are the bin boundaries
sBinData – is (optional) sub structure
-
inline BinningData(const BinningData &bdata)
Copy constructor.
- Parameters
bdata – is the source object
-
BinningData() = default
-
~BinningData() = default
-
inline size_t bins() const
Return the number of bins - including sub bins.
-
inline const std::vector<float> &boundaries() const
Return the boundaries - including sub boundaries.
- Returns
vector of floats indicating the boundary values
-
inline float center(size_t bin) const
Get the center value of a bin.
- Parameters
bin – is the bin for which the center value is requested
- Returns
float value according to the bin center
-
inline float centerValue(size_t bin) const
access to the center value this uses the bin boundary vector, it also works with sub structure
- Parameters
bin – is the bin for which the value is requested, if bin > nbins it is set to max
- Returns
the center value of the bin is given
-
inline bool inside(const Vector3 &position) const
Check if bin is inside from Vector3.
- Parameters
position – is the search position in global coordinated
- Returns
boolen if this is inside() method is true
-
inline bool inside(const Vector2 &lposition) const
Check if bin is inside from Vector2.
- Parameters
lposition – is the search position in global coordinated
- Returns
boolen if this is inside() method is true
-
inline int nextDirection(const Vector3 &position, const Vector3 &dir) const
Layer next direction is needed.
- Parameters
position – is the start search position
dir – is the direction
- Returns
integer that indicates which direction to move
-
inline BinningData &operator=(const BinningData &bdata)
Assignment operator.
- Parameters
bdata – is the source object
-
inline bool operator==(const BinningData &bData) const
Equality operator.
- Parameters
bData – is the binning data to be checked against
- Returns
a boolean indicating if they are the same
-
inline size_t search(float value) const
Generic search - forwards to correct function pointer.
- Parameters
value – is the searchvalue as float
- Returns
bin according tot this
-
inline size_t searchGlobal(const Vector3 &position) const
Generic search from a 3D position — corresponds to global coordinate schema.
- Parameters
position – is the search position in global coordinated
- Returns
bin according tot this
-
inline size_t searchLocal(const Vector2 &lposition) const
Generic search from a 2D position — corresponds to local coordinate schema.
- Parameters
lposition – is the search position in local coordinated
- Returns
bin according tot this
-
inline size_t searchWithSubStructure(float value) const
Generic search with sub structure.
forwards to correct function pointer
- Parameters
value – is the searchvalue as float
- Returns
bin according tot this
-
inline float value(const Vector2 &lposition) const
Take the right float value.
- Parameters
lposition – assumes the correct local position expression
- Returns
float value according to the binning setup
-
inline float value(const Vector3 &position) const
Take the right float value.
- Parameters
position – is the global position
- Returns
float value according to the binning setup
-
inline float width(size_t bin) const
Get the width of a bin.
- Parameters
bin – is the bin for which the width is requested
- Returns
float value of width
Public Members
-
BinningValue binvalue
binning value: binX, binY, binZ, binR …
-
float max
maximum value
-
float min
minimum value
-
BinningOption option
binning option: open, closed
-
float step
binning step
-
bool subBinningAdditive
sub structure: additive or multipicative
-
std::unique_ptr<const BinningData> subBinningData
sub structure: describe some sub binning
-
BinningType type
binning type: equidistant, arbitrary
-
bool zdim
zero dimensional binning : direct access
-
class BinUtility
- #include <Acts/Utilities/BinUtility.hpp>
The BinUtility class that translated global and local position into a bins of a BinnedArray, most performant is equidistant binning without a transform, however, optionally a transform can be provided, e.g.
for binning on shifted object, the transform is usually shared with the geometric object the Array is defined on, for performance reasons, also the inverse transform is stored.
Public Functions
-
inline BinUtility()
Constructor for equidistant.
-
inline BinUtility(const Transform3 &tForm)
Constructor with only a Transform3.
- Parameters
tForm – is the local to global transform
-
inline BinUtility(const BinningData &bData, const Transform3 &tForm = Transform3::Identity())
Constructor from BinningData directly.
- Parameters
bData – is the provided binning data
tForm – is the (optional) transform
-
inline BinUtility(size_t bins, float min, float max, BinningOption opt = open, BinningValue value = binX, const Transform3 &tForm = Transform3::Identity())
Constructor for equidistant.
- Parameters
bins – is the number of bins
min – in the minimal value
max – is the maximal value
opt – is the binning option : open, closed
value – is the binninb value : binX, binY, binZ, etc.
tForm – is the (optional) transform
-
inline BinUtility(std::vector<float> &bValues, BinningOption opt = open, BinningValue value = binPhi, const Transform3 &tForm = Transform3::Identity())
Constructor for arbitrary.
- Parameters
bValues – is the boundary values of the binning
opt – is the binning option : open, closed
value – is the binninb value : binX, binY, binZ, etc.
tForm – is the (optional) transform
-
inline BinUtility(const BinUtility &sbu)
Copy constructor.
- Parameters
sbu – is the source bin utility
-
~BinUtility() = default
Virtual Destructor.
-
inline size_t bin(const Vector3 &position, size_t ba = 0) const
Bin from a 3D vector (already in binning frame)
- Parameters
position – is the 3D position to be evaluated
ba – is the bin dimension
- Returns
is the bin value
-
inline size_t bin(const Vector2 &lposition, size_t ba = 0) const
Bin from a 2D vector (following local parameters defintitions)
no optional transform applied
USE WITH CARE !!
You need to make sure that the local position is actually in the binning frame of the BinUtility
- Parameters
lposition – is the local position to be set
ba – is the bin dimension
- Returns
bin calculated from local
-
inline const std::vector<BinningData> &binningData() const
Return the binning data vector.
-
inline BinningValue binningValue(size_t ba = 0) const
The type/value of the binning.
- Parameters
ba – is the binaccessor
- Returns
the binning value of the accessor entry
-
inline size_t bins() const
Return the total number of bins.
-
inline size_t bins(size_t ba) const
Number of bins.
- Parameters
ba – is the binaccessor
- Returns
size_t is the bins of the accessor entry
-
inline std::array<size_t, 3> binTriple(const Vector3 &position) const
Bin-triple fast access.
calculate the bin triple with one transform
- Parameters
position – is the 3D position to be evaluated
- Returns
is the bin value in 3D
-
inline size_t dimensions() const
First bin maximal value.
- Returns
the dimenstion of the binning data
-
inline bool inside(const Vector3 &position) const
Check if bin is inside from Vector2 - optional transform applied.
- Parameters
position – is the global position to be evaluated
- Returns
is a boolean check
-
inline bool inside(const Vector2 &lposition) const
Check if bin is inside from Vector2 - no optional transform applied.
- Parameters
lposition – is the local position to be evaluated
- Returns
is a boolean check
-
inline size_t max(size_t ba = 0) const
First bin maximal value.
- Parameters
ba – is the binaccessor
- Returns
size_t is the maximal bin of the accessor entry
-
inline int nextDirection(const Vector3 &position, const Vector3 &direction, size_t ba = 0) const
Return the oder direction for fast interlinking.
- Parameters
position – is the global position for the next search
direction – is the global position for the next search
ba – is the bin accessor
- Returns
the next bin
-
inline BinUtility &operator+=(const BinUtility &gbu)
Operator+= to make multidimensional BinUtility.
- Parameters
gbu – is the additional BinUtility to be chosen
-
inline BinUtility &operator=(const BinUtility &sbu)
Assignment operator.
- Parameters
sbu – is the source bin utility
-
inline bool operator==(const BinUtility &other) const
Equality operator.
-
inline size_t serialize(const std::array<size_t, 3> &bin) const
Serialize the bin triple.
this creates a simple size_t from a triple object
- Parameters
bin – is the bin to be serialized
-
inline std::ostream &toStream(std::ostream &sl) const
Output Method for std::ostream, to be overloaded by child classes.
- Parameters
sl – is the ostream to be dumped into
-
inline const Transform3 &transform() const
Transform applied to global positions before lookup.
- Returns
Shared pointer to transform
-
inline BinUtility()
-
class BoundaryCheck
- #include <Acts/Surfaces/BoundaryCheck.hpp>
The BoundaryCheck class provides boundary checks and distance calculations for aligned box-like and polygonal boundaries on local surfaces.
Different types of boundary checks are supported and are transparently selected when calling the
isInside(...)
anddistance(...)
methods:Hard checks w/o any tolerances
Tolerance-based checks in one or in both local coordinates
Chi2-based checks based on a covariance matrix. Non-vanishing correlations are correctly taken into account.
With a defined covariance matrix, the closest point and the distance are not defined along the usual Euclidean metric, but by the Mahalanobis distance induced by the covariance.
Public Types
-
enum Type
Values:
-
enumerator eNone
disable boundary check
-
enumerator eAbsolute
absolute cut
-
enumerator eChi2
chi2-based cut with full correlations
-
enumerator eNone
Public Functions
-
inline BoundaryCheck(bool check)
Construct either hard cut in both dimensions or no cut at all.
-
inline BoundaryCheck(bool checkLocal0, bool checkLocal1, double tolerance0 = 0, double tolerance1 = 0)
Construct a tolerance based check.
- Parameters
checkLocal0 – Boolean directive to check coordinate 0
checkLocal1 – Boolean directive to check coordinate 1
tolerance0 – Tolerance along coordinate 0
tolerance1 – Tolerance along coordinate 1
-
inline BoundaryCheck(const SymMatrix2 &localCovariance, double sigmaMax = 1)
Construct a chi2-based check.
- Parameters
localCovariance – Coverance matrix in local coordinates
sigmaMax – Significance for the compatibility test
-
template<typename Vector2Container>
inline Acts::Vector2 computeClosestPointOnPolygon(const Acts::Vector2 &point, const Vector2Container &vertices) const
-
inline SymMatrix2 covariance() const
-
template<typename Vector2Container>
inline double distance(const Vector2 &point, const Vector2Container &vertices) const Calculate the signed, weighted, closest distance to a polygonal boundary.
If a covariance is defined, the distance is the corresponding Mahalanobis distance. Otherwise, it is the Eucleadian distance.
- Parameters
point – Test point
vertices – Forward iterable container of convex polygon vertices. Calling
std::begin
/std::end
on the container must return an iterator where*it
must be convertible to anActs::Vector2
.
- Returns
Negative value if inside, positive if outside
-
inline double distance(const Vector2 &point, const Vector2 &lowerLeft, const Vector2 &upperRight) const
Calculate the signed, weighted, closest distance to an aligned box.
If a covariance is defined, the distance is the corresponding Mahalanobis distance. Otherwise, it is the Eucleadian distance.
- Parameters
point – Test point
lowerLeft – Minimal vertex of the box
upperRight – Maximal vertex of the box
- Returns
Negative value if inside, positive if outside
-
template<typename Vector2Container>
inline bool isInside(const Vector2 &point, const Vector2Container &vertices) const Check if the point is inside a polygon.
The check takes into account whether tolerances or covariances are defined for the boundary check.
- Parameters
point – Test point
vertices – Forward iterable container of convex polygon vertices. Calling
std::begin
/std::end
on the container must return an iterator where*it
must be convertible to anActs::Vector2
.
-
inline bool isInside(const Vector2 &point, const Vector2 &lowerLeft, const Vector2 &upperRight) const
Check if the point is inside a box aligned with the local axes.
The check takes into account whether tolerances or covariances are defined for the boundary check.
- Parameters
point – Test point
lowerLeft – Minimal vertex of the box
upperRight – Maximal vertex of the box
-
inline operator bool() const
-
inline bool operator!() const
-
inline const Vector2 &tolerance() const
-
inline Type type() const
Broadcast the type.
-
template<class volume_t>
class BoundarySurfaceT - #include <Acts/Geometry/BoundarySurfaceT.hpp>
The boundary surface class combines a Surface with the information of a volume. It’s templated in the type of volume in order to allow for a return type tat is usable in the navigation stream.
Note
along/oppose definitions are given with respect to the normal vector of the boundary surface.
- Template Parameters
volume_t – the type of volume.
Public Functions
-
inline BoundarySurfaceT()
Constructor for a Boundary with exact two Volumes attached to it.
usually used in a volume constructor
- Parameters
surface – The unqiue surface the boundary represents
inside – The inside volume the bounday surface points to
outside – The outside volume the boundary surface points to
Constructor for a Boundary with exact two Volumes attached to it.
usually used in a volume constructor
- Parameters
surface – The unqiue surface the boundary represents
inside – The inside volume the bounday surface points to
outside – The outside volume the boundary surface points to
Constructor for a Boundary with exact multiple Volumes attached to it.
usually used in a volume constructor
- Parameters
surface – The unqiue surface the boundary represents
insideArray – The inside volume array the bounday surface points to
outsideArray – The outside volume array the boundary surface points to
-
virtual ~BoundarySurfaceT() = default
Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on the TrackParameters and the requested direction.
- Parameters
gctx – The current geometry context object, e.g. alignment
pos – The global position on surface
mom – The direction on the surface
pdir – is an aditional direction corrective
- Returns
The attached volume at that position
Helper method: attach a Volume to this BoundarySurfaceT this is done during the geometry construction.
- Parameters
volume – The volume to be attached
navDir – The navigation direction for attaching
Helper method: attach a Volume to this BoundarySurfaceT this is done during the geometry construction.
- Parameters
volumes – The volume array to be attached
navDir – The navigation direction for attaching
-
template<class parameters_t>
inline bool onBoundary(const GeometryContext &gctx, const parameters_t &pars) const templated onBoundary method
- Template Parameters
parameters_t – are the parameters to be checked
- Parameters
gctx – The current geometry context object, e.g. alignment
pars – The parameters used for this call
-
inline virtual const Surface &surfaceRepresentation() const
The Surface Representation of this.
-
class CartesianSegmentation : public Acts::Segmentation
- #include <Acts/Digitization/CartesianSegmentation.hpp>
Segmentation Base class.
Segementation class for generic pixel, strixels and strip segmentations in a cartesian frame, this uses a cartesian X/Y local surface definition
The calculation can be done in full 3D, i.e. the segments of the path through the planar module are calculated in a 3D model - or in 2D, when the entire calculation is done on the projective surface. When the 2D option is used, segmentation surfaces are not created. The 2D calculation is faster and uses less memory, however, effects witin the sensor volume can not be easily integrated
Conventions:
3D positions are within the 3D frame of the module
2D positions are corrected to the readout surface they need to be corrected by the lorentzShift for the parameter surface in the center of the surface)
Public Functions
Constructor for all same-size pixels or strips (in cas numCellsY is set to 1)
- Parameters
mBounds – are the rectangle bounds of the sensitive volume
numCellsX – is the number of cells in X
numCellsY – is the number of cells in Y
Note
if both RectangleBounds and BinUtility are provided, no check is done for consitency
- Parameters
bUtility – is the bin Utility,
mBounds – are the rectangle bounds if provided for memory optimisation
-
~CartesianSegmentation() override
Virtual Destructor.
-
inline virtual const BinUtility &binUtility() const final
return the bin utility that defines the readout segmentation
-
inline virtual DigitizationCell cell(const Vector3 &position) const final
Get the digitization cell fropm a 3D position.
ignores the shift, i.e. assumenes in to be in cell frame
- Parameters
position – is the position for which the cell is requested
- Returns
is a cell with cell ids
-
inline virtual DigitizationCell cell(const Vector2 &position) const final
Get the digitization cell fropm a 3D position.
ignores the shift, i.e. assumenes in to be in cell frame
- Parameters
position – is the position for which the cell is requested
- Returns
is a cell with cell ids
-
virtual Vector2 cellPosition(const DigitizationCell &dCell) const final
Calculate the cell Position from the Id.
- Parameters
dCell – the digitization cell
- Returns
the center position of the associated cell
-
virtual void createSegmentationSurfaces(SurfacePtrVector &boundarySurfaces, SurfacePtrVector &segmentationSurfacesX, SurfacePtrVector &segmentationSurfacesY, double halfThickness, int readoutDirection = 1., double lorentzAngle = 0.) const final
Create the segmentation surfaces in X.
This method is only used if the full 3D digitization is done
Create the segmentation surfaces in X and Y for rectangular shapes These are needed for a full three dimensional module
- Parameters
boundarySurfaces – vector to be filled
segmentationSurfacesX – are the segmetation boundaries in X
segmentationSurfacesY – are the segmetation boundaries in Y
halfThickness – is the half thickness in z of the module
readoutDirection – is the direction w.r.t normal vector where the readout is given : -1, 0, 1 possible
lorentzAngle – is the lorentz angle measured from the local z towards x axis
-
virtual DigitizationStep digitizationStep(const Vector3 &start, const Vector3 &end, double halfThickness, int readoutDirection = 1, double lorentzAngle = 0.) const final
Fill the associated digitization cell from this start and end position correct for lorentz effect if needed.
Fill the associated digitization cell from the start and end position in 3D correct for lorentz effect if needed.
- Parameters
start – is the start position of the step
end – is the end position of the step
halfThickness – is the half thickness in z
readoutDirection – is the readout direction with respect to local z
lorentzAngle – is the lorentz angle measured from local z towards x
- Returns
is a fully calculated digitzation step
-
inline virtual const PlanarBounds &moduleBounds() const final
return the surface bounds by reference specialization for Rectangle Bounds
-
inline std::pair<double, double> pitch() const
return the pitch sizes as a pair
-
template<typename propagator_t, typename traj_t>
class CombinatorialKalmanFilter - #include <Acts/TrackFinding/CombinatorialKalmanFilter.hpp>
Combinatorial Kalman filter to find tracks.
The CombinatorialKalmanFilter contains an Actor and a Sequencer sub-class. The Sequencer has to be part of the Navigator of the Propagator in order to initialize and provide the measurement surfaces.
The Actor is part of the Propagation call and does the Kalman update and eventually the smoothing. Updater, Smoother and Calibrator are given to the Actor for further use:
The Updater is the implemented kalman updater formalism, it runs via a visitor pattern through the measurements.
The Smoother is called at the end of the filtering (track finding) by the Actor.
Measurements are not required to be ordered for the CombinatorialKalmanFilter, measurement ordering needs to be figured out by the navigation of the propagator.
The void components are provided mainly for unit testing.
- Template Parameters
propagator_t – Type of the propagator
Public Functions
-
CombinatorialKalmanFilter() = delete
Default constructor is deleted.
-
inline CombinatorialKalmanFilter(propagator_t pPropagator)
Constructor from arguments.
-
template<typename source_link_iterator_t, typename start_parameters_container_t, typename parameters_t = BoundTrackParameters>
inline std::vector<Result<CombinatorialKalmanFilterResult<traj_t>>> findTracks(const start_parameters_container_t &initialParameters, const CombinatorialKalmanFilterOptions<source_link_iterator_t, traj_t> &tfOptions) const Combinatorial Kalman Filter implementation, calls the Kalman filter and smoother.
Note
The input measurements are given in the form of
SourceLinks
. It’scalibrator_t's
job to turn them into calibrated measurements used in the track finding.- Template Parameters
source_link_iterator_t – Type of the source link iterator
start_parameters_container_t – Type of the initial parameters container
calibrator_t – Type of the source link calibrator
measurement_selector_t – Type of the measurement selector
parameters_t – Type of parameters used for local parameters
- Parameters
initialParameters – The initial track parameters
tfOptions – CombinatorialKalmanFilterOptions steering the track finding
- Returns
a container of track finding result for all the initial track parameters
-
template<typename traj_t>
struct CombinatorialKalmanFilterExtensions - #include <Acts/TrackFinding/CombinatorialKalmanFilter.hpp>
Extension struct which holds the delegates to customize the CKF behavior.
Public Types
-
using BranchStopper = Delegate<bool(const CombinatorialKalmanFilterTipState&)>
-
using candidate_container_t = typename std::vector<typename MultiTrajectory<traj_t>::TrackStateProxy>
-
using MeasurementSelector = Delegate<Result<std::pair<typename candidate_container_t::iterator, typename candidate_container_t::iterator>>(candidate_container_t &trackStates, bool&, LoggerWrapper)>
Public Functions
-
inline CombinatorialKalmanFilterExtensions()
Default constructor which connects the default void components.
Public Members
-
BranchStopper branchStopper
-
KalmanFitterExtensions<traj_t>::Calibrator calibrator
The Calibrator is a dedicated calibration algorithm that allows to calibrate measurements using track information, this could be e.g.
sagging for wires, module deformations, etc.
-
MeasurementSelector measurementSelector
The measurement selector is called during the filtering by the Actor.
-
KalmanFitterExtensions<traj_t>::Smoother smoother
The smoother back-propagates measurement information along the track.
-
KalmanFitterExtensions<traj_t>::Updater updater
The updater incorporates measurement information into the track parameters.
-
using BranchStopper = Delegate<bool(const CombinatorialKalmanFilterTipState&)>
-
template<typename source_link_iterator_t, typename traj_t>
struct CombinatorialKalmanFilterOptions - #include <Acts/TrackFinding/CombinatorialKalmanFilter.hpp>
Combined options for the combinatorial Kalman filter.
- Template Parameters
source_link_accessor_t – Source link accessor type, should be semiregular.
Public Types
-
using SourceLinkAccessor = SourceLinkAccessorDelegate<source_link_iterator_t>
-
using SourceLinkIterator = source_link_iterator_t
Public Functions
-
inline CombinatorialKalmanFilterOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, std::reference_wrapper<const CalibrationContext> cctx, SourceLinkAccessor accessor_, CombinatorialKalmanFilterExtensions<traj_t> extensions_, LoggerWrapper logger_, const PropagatorPlainOptions &pOptions, const Surface *rSurface = nullptr, bool mScattering = true, bool eLoss = true, bool rSmoothing = true)
PropagatorOptions with context.
- Parameters
gctx – The geometry context for this track finding/fitting
mctx – The magnetic context for this track finding/fitting
cctx – The calibration context for this track finding/fitting
accessor_ – The source link accessor
extensions_ – The extension struct
logger_ – The logger wrapper
pOptions – The plain propagator options
rSurface – The reference surface for the eventual track fitting to be expressed at
mScattering – Whether to include multiple scattering
eLoss – Whether to include energy loss
rSmoothing – Whether to run smoothing to get fitted parameter
-
CombinatorialKalmanFilterOptions() = delete
Contexts are required and the options must not be default-constructible.
Public Members
-
std::reference_wrapper<const CalibrationContext> calibrationContext
context object for the calibration
-
bool energyLoss = true
Whether to consider energy loss.
-
CombinatorialKalmanFilterExtensions<traj_t> extensions
The filter extensions.
-
std::reference_wrapper<const GeometryContext> geoContext
Context object for the geometry.
-
LoggerWrapper logger
Logger instance.
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
Context object for the magnetic field.
-
bool multipleScattering = true
Whether to consider multiple scattering.
-
PropagatorPlainOptions propagatorPlainOptions
The trivial propagator options.
-
const Surface *referenceSurface = nullptr
The reference Surface.
-
bool smoothing = true
Whether to run smoothing to get fitted parameter.
-
SourceLinkAccessor sourcelinkAccessor
The source link accessor.
-
template<typename traj_t>
struct CombinatorialKalmanFilterResult - #include <Acts/TrackFinding/CombinatorialKalmanFilter.hpp>
Public Members
-
std::vector<std::pair<MultiTrajectoryTraits::IndexType, CombinatorialKalmanFilterTipState>> activeTips
-
bool filtered = false
-
bool finished = false
-
std::unordered_map<MultiTrajectoryTraits::IndexType, BoundTrackParameters> fittedParameters
-
std::shared_ptr<traj_t> fittedStates
-
MultiTrajectoryTraits::IndexType iSmoothed = 0
-
std::vector<MultiTrajectoryTraits::IndexType> lastMeasurementIndices
-
std::vector<MultiTrajectoryTraits::IndexType> lastTrackIndices
-
bool smoothed = false
-
std::unordered_map<const Surface*, std::unordered_map<size_t, size_t>> sourcelinkTips
-
std::shared_ptr<traj_t> stateBuffer
-
std::vector<typename MultiTrajectory<traj_t>::TrackStateProxy> trackStateCandidates
-
std::vector<std::pair<MultiTrajectoryTraits::IndexType, CombinatorialKalmanFilterTipState>> activeTips
-
struct CombinatorialKalmanFilterTipState
- #include <Acts/TrackFinding/CombinatorialKalmanFilter.hpp>
Track quality summary for one trajectory.
This could be used to decide if a track is to be recorded when the filtering is done or to be terminated due to its bad quality
Public Members
-
size_t nHoles = 0
-
size_t nMeasurements = 0
-
size_t nOutliers = 0
-
size_t nSensitiveSurfaces = 0
-
size_t nStates = 0
-
size_t nHoles = 0
-
class ConeBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/ConeBounds.hpp>
Bounds for a conical surface, the opening angle is stored in \( \tan(\alpha) \) and always positively defined.
The cone can open to both sides, steered by \( z_min \) and \( z_max \).
Public Types
-
enum BoundValues
Values:
-
enumerator eAlpha
-
enumerator eMinZ
-
enumerator eMaxZ
-
enumerator eHalfPhiSector
-
enumerator eAveragePhi
-
enumerator eSize
-
enumerator eAlpha
Public Functions
-
ConeBounds() = delete
-
ConeBounds(double alpha, bool symm, double halfphi = M_PI, double avphi = 0.) noexcept(false)
Constructor - open cone with alpha, by default a full cone but optionally can make a conical section.
- Parameters
alpha – is the opening angle of the cone
symm – is the boolean indicating if the cone is symmetric in +/- z
halfphi – is the half opening angle (default is pi)
avphi – is the phi value around which the bounds are opened (default=0)
-
ConeBounds(double alpha, double minz, double maxz, double halfphi = M_PI, double avphi = 0.) noexcept(false)
Constructor - open cone with alpha, minz and maxz, by default a full cone but can optionally make it a conical section.
- Parameters
alpha – is the opening angle of the cone
minz – cone expanding from minimal z
maxz – cone expanding to maximal z
halfphi – is the half opening angle (default is pi)
avphi – is the phi value around which the bounds are opened (default=0)
-
ConeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from parameters array.
- Parameters
values – The parameter array
-
~ConeBounds() override = default
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck = true) const final
inside method for local position
- Parameters
lposition – is the local position to be checked
bcheck – is the boundary check directive
- Returns
is a boolean indicating if the position is inside
-
inline double r(double z) const
Return the radius at a specific z values.
- Parameters
z – is the z value for which r is requested
- Returns
is the r value associated with z
-
inline double tanAlpha() const
Return tangent of alpha (pre-computed)
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostrea into which the dump is done
- Returns
is the input obect
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
enum BoundValues
-
class ConeLayer : public virtual Acts::ConeSurface, public Acts::Layer
- #include <Acts/Geometry/ConeLayer.hpp>
Class to describe a conical detector layer for tracking, it inhertis from both, Layer base class and ConeSurface class.
Public Functions
-
ConeLayer() = delete
-
ConeLayer(const ConeLayer &cla) = delete
-
~ConeLayer() override = default
-
virtual const ConeSurface &surfaceRepresentation() const override
Transforms the layer into a Surface representation for extrapolation.
-
virtual ConeSurface &surfaceRepresentation() override
Public Static Functions
Factory for shared layer.
- Parameters
transform – is the 3D transform that poisitions the layer in 3D frame
cbounds – is the conical bound description
surfaceArray – is the array of sensitive surfaces
thickness – is the layer thickness along the normal axis
ad – is the approach descriptor for navigation towards the layer
laytyp – is the layer type
- Returns
is a shared pointer to a layer
-
ConeLayer() = delete
-
class ConeSurface : public Acts::Surface
- #include <Acts/Surfaces/ConeSurface.hpp>
Class for a conical surface in the Tracking geometry.
It inherits from Surface.
The ConeSurface is special since no corresponding Track parameters exist since they’re numerical instable at the tip of the cone. Propagations to a cone surface will be returned in curvilinear coordinates.
Subclassed by Acts::ConeLayer
Public Functions
-
ConeSurface() = delete
-
~ConeSurface() override = default
-
virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const final
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. the alignment parameters
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const final
The binning position method - is overloaded for r-type binning.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – defines the type of binning applied in the global frame
- Returns
The return type is a vector for positioning in the global frame
-
virtual const ConeBounds &bounds() const final
This method returns the ConeBounds by reference.
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const final
Global to local transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position to be transformed
momentum – is the global momentum (ignored in this operation)
tolerance – optional tolerance within which a point is considered valid on surface
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck) const final
Straight line intersection schema from position/direction.
If possible returns both solutions for the cylinder
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position to start from
direction – The direction at start
bcheck – the Boundary Check
- Returns
SurfaceIntersection object (contains intersection & surface)
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const final
Local to global transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position to be transformed
momentum – is the global momentum (ignored in this operation)
- Returns
The global position by value
-
virtual std::string name() const override
Return properly formatted class name for screen output.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final
Return method for surface normal information.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position at normal vector request
- Returns
Vector3 normal vector in global frame
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final
Return method for surface normal information.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position as normal vector base
- Returns
Vector3 normal vector in global frame
-
ConeSurface &operator=(const ConeSurface &other)
Assignment operator.
- Parameters
other – is the source surface for the assignment
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final
The pathCorrection for derived classes with thickness.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global potion at the correction point
direction – is the momentum direction at the correction point
- Returns
is the path correction due to incident angle
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const override
Return a Polyhedron for the surfaces.
Note
that a surface transform can invalidate the extrema in the transformed space
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, it represents the full 2*M_PI coverange, if lseg is set to 1 only the extrema are given
- Returns
A list of vertices and a face/facett description of it
-
virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum) const final
Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface.
the default implementation is the RotationMatrix3 of the transform
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position where the measurement frame is constructed
momentum – is the momentum used for the measurement frame construction
- Returns
matrix that indicates the measurement frame
-
virtual Vector3 rotSymmetryAxis(const GeometryContext &gctx) const
- Parameters
gctx – The current geometry context object, e.g. alignment
-
virtual SurfaceType type() const override
Return the surface type.
-
ConeSurface() = delete
-
class ConeVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/ConeVolumeBounds.hpp>
Volume bound class for describing conical volumes either with cylindrical inlay or outer boundary, it also allows for a sectoral description.
Public Types
-
enum BoundValues
for readability
Values:
-
enumerator eInnerAlpha
-
enumerator eInnerOffsetZ
-
enumerator eOuterAlpha
-
enumerator eOuterOffsetZ
-
enumerator eHalfLengthZ
-
enumerator eAveragePhi
-
enumerator eHalfPhiSector
-
enumerator eSize
-
enumerator eInnerAlpha
Public Functions
-
ConeVolumeBounds() = delete
-
ConeVolumeBounds(double innerAlpha, double innerTipZ, double outerAlpha, double outerOffsetZ, double halflengthZ, double averagePhi, double halfPhiSector) noexcept(false)
Constructor - for general cone-cone setups.
- Parameters
innerAlpha – The opening angle of the inner cone (0 if no cone)
innerTipZ – The tip z position in of the inner cone, w.r.t center
outerAlpha – The opening angle of the outer cone (0 if no cone)
outerOffsetZ – The tip z position in of the outer cone, w.r.t center
halflengthZ – The minimum z value of the inner and outer cones
averagePhi – The phi orientation of the sector
halfPhiSector – The opening angle phi sector
-
ConeVolumeBounds(double cylinderR, double alpha, double offsetZ, double halflengthZ, double averagePhi, double halfPhiSector) noexcept(false)
Constructor - for general cylidner-cone setups.
Note
depending on cylinderR > coneR it is constructing a cone with cylindrical cutout or a cylinder with conical cutout
- Parameters
cylinderR – The inner radius of the cylinder
alpha – The opening angle of the cone (0 if no cone)
offsetZ – The tip z position in of the cone, w.r.t center
halflengthZ – The minimum z value of the inner and outer cones
averagePhi – The phi orientation of the sector (defaulted to 0)
halfPhiSector – The opening angle phi sector
-
inline ConeVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from a fixed size array.
- Parameters
values – The bound values
-
ConeVolumeBounds(const ConeVolumeBounds &cobo) = default
-
~ConeVolumeBounds() override = default
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
inline double innerRmax() const
-
inline double innerRmin() const
-
inline double innerTanAlpha() const
-
virtual bool inside(const Vector3 &pos, double tol = 0.) const final
This method checks if position in the 3D volume frame is inside the cylinder.
- Parameters
pos – is the position in volume frame to be checked
tol – is the absolute tolerance to be applied
-
ConeVolumeBounds &operator=(const ConeVolumeBounds &cobo) = default
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const final
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
inline double outerRmax() const
-
inline double outerRmin() const
-
inline double outerTanAlpha() const
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is ostream operator to be dumped into
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
enum BoundValues
-
class ConstantBField : public Acts::MagneticFieldProvider
- #include <Acts/MagneticField/ConstantBField.hpp>
This class implements a simple constant magnetic field.
The magnetic field value has to be set at creation time, but can be updated later on.
Public Functions
-
inline explicit ConstantBField(Vector3 B)
Construct constant magnetic field from field vector.
- Parameters
B – [in] magnetic field vector in global coordinate system
-
inline Vector3 getField() const
Get the B field at a position.
-
inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value at a given location.
Requires a cache object created through makeCache().
Note
The
position
is ignored and only kept as argument to provide a consistent interface with other magnetic field services.- Parameters
position – [in] global 3D position for the lookup
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector at given position
-
inline virtual Result<Vector3> getFieldGradient(const Vector3 &position, ActsMatrix<3, 3> &derivative, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value its its gradient.
Requires a cache object created through makeCache().
Note
The
position
is ignored and only kept as argument to provide a consistent interface with other magnetic field services.Note
currently the derivative is not calculated
- Parameters
position – [in] global 3D position
derivative – [out] gradient of magnetic field vector as (3x3) matrix
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector
-
inline bool isInside(const Vector3 &position) const
check whether given 3D position is inside look-up domain
- Parameters
position – [in] global 3D position
- Returns
Always true for constant magnetic field
-
inline virtual Acts::MagneticFieldProvider::Cache makeCache(const Acts::MagneticFieldContext &mctx) const override
Make an opaque cache for the magnetic field.
Instructs the specific implementation to generate a
Cache
instance for magnetic field lookup.- Parameters
mctx – The magnetic field context to generate cache for
- Returns
Cache The opaque cache object
-
inline void setField(const Vector3 &B)
update magnetic field vector
- Parameters
B – [in] magnetic field vector in global coordinate system
-
struct Cache
- #include <Acts/MagneticField/ConstantBField.hpp>
Public Functions
-
inline Cache(const MagneticFieldContext&)
constructor with context
-
inline Cache(const MagneticFieldContext&)
-
inline explicit ConstantBField(Vector3 B)
-
class ConstrainedStep
- #include <Acts/Propagator/ConstrainedStep.hpp>
A constrained step class for the steppers.
As simple as this class looks it hides a few very important details:
Overstepping handling. The step size sign will flip if we happened to pass our target.
Convergence handling. Smaller and smaller step sizes have to be used in order to converge on a target.
Because of the points mentioned above, the update function will always prefer step sizes that point opposite the nagivation direction. A side effect of this is that we will propagate in the opposite direction if the target is “behind us”.
The hierarchy is:
Overstepping resolution / backpropagation
Convergence
Step into the void with
std::numeric_limits<Scalar>max()
Public Types
-
using Scalar = ActsScalar
-
enum Type
the types of constraints from accuracy - this can vary up and down given a good step estimator from actor - this would be a typical navigation step from aborter - this would be a target condition from user - this is user given for what reason ever
Values:
-
enumerator accuracy
-
enumerator actor
-
enumerator aborter
-
enumerator user
-
enumerator accuracy
Public Functions
-
constexpr ConstrainedStep() = default
-
inline explicit constexpr ConstrainedStep(Scalar value)
constructor from Scalar navigation direction is inferred by the sign of the step size
- Parameters
value – is the user given initial value
-
inline constexpr Type currentType() const
Access the currently leading type.
-
inline constexpr void release(Type type)
release a certain constraint value
- Parameters
type – is the constraint type to be released
-
inline constexpr void scale(Scalar factor)
-
inline constexpr void setValue(Scalar value)
set accuracy by one Scalar
this will set only the accuracy, as this is the most exposed to the Propagator
- Parameters
value – is the new accuracy value
-
inline std::ostream &toStream(std::ostream &os) const
-
inline std::string toString() const
-
inline constexpr void update(Scalar value, Type type, bool releaseStep = false)
Update the step size of a certain type.
Only navigation and target abortion step size updates may change the sign due to overstepping
- Parameters
value – is the new value to be updated
type – is the constraint type
releaseStep – Allow step size to increase again
-
inline constexpr Scalar value() const
returns the min step size
Public Members
-
size_t nStepTrials = std::numeric_limits<size_t>::max()
Number of iterations needed by the stepsize finder (e.g.
Runge-Kutta) of the stepper.
-
template<int N>
class ConvexPolygonBounds : public Acts::ConvexPolygonBoundsBase - #include <Acts/Surfaces/ConvexPolygonBounds.hpp>
This is the actual implementation of the bounds.
It is templated on the number of vertices, but there is a specialization for dynamic number of vertices, where the underlying storage is then a vector.
- Template Parameters
N – Number of vertices
Public Types
-
using value_array = std::array<double, eSize>
Type that’s used to store the vertices, in this case a fixed size array.
-
using vertex_array = std::array<Vector2, num_vertices>
Type that’s used to store the vertices, in this case a fixed size array.
Public Functions
-
ConvexPolygonBounds() = delete
-
ConvexPolygonBounds(const std::vector<Vector2> &vertices) noexcept(false)
Constructor from a vector of vertices, to facilitate construction.
This will throw if the vector size does not match
num_vertices
. This will throw if the vertices do not form a convex polygon.- Parameters
vertices – The list of vertices.
-
ConvexPolygonBounds(const vertex_array &vertices) noexcept(false)
Constructor from a fixed size array of vertices.
This will throw if the vertices do not form a convex polygon.
- Parameters
vertices – The vertices
-
ConvexPolygonBounds(const value_array &values) noexcept(false)
Constructor from a fixed size array of parameters This will throw if the vertices do not form a convex polygon.
- Parameters
values – The values to build up the vertices
-
~ConvexPolygonBounds() override = default
-
virtual const RectangleBounds &boundingBox() const final
Return a rectangle bounds object that encloses this polygon.
- Returns
The rectangular bounds
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Return whether a local 2D point lies inside of the bounds defined by this object.
- Parameters
lposition – The local position to check
bcheck – The
BoundaryCheck
object handling tolerances.
- Returns
Whether the points is inside
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const final
Return the vertices.
Note
the number of segements is ignored in this representation
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
template<>
class ConvexPolygonBounds<PolygonDynamic> : public Acts::ConvexPolygonBoundsBase - #include <Acts/Surfaces/ConvexPolygonBounds.hpp>
This is the specialization handling a polygon with a dynamic number of points.
It can accept any number of points.
Public Functions
-
ConvexPolygonBounds() = delete
Default constructor, deleted.
-
ConvexPolygonBounds(const std::vector<Vector2> &vertices)
Constructor from a vector of vertices, to facilitate construction.
This will throw if the vertices do not form a convex polygon.
- Parameters
vertices – The list of vertices.
-
~ConvexPolygonBounds() override = default
Defaulted destructor.
-
virtual const RectangleBounds &boundingBox() const final
Return a rectangle bounds object that encloses this polygon.
- Returns
The rectangular bounds
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Return whether a local 2D point lies inside of the bounds defined by this object.
- Parameters
lposition – The local position to check
bcheck – The
BoundaryCheck
object handling tolerances.
- Returns
Whether the points is inside
-
virtual BoundsType type() const final
Return the bounds type of this bounds object.
- Returns
The bounds type
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const final
Return the vertices.
Note
the number of segements is ignored in this representation
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
ConvexPolygonBounds() = delete
-
class ConvexPolygonBoundsBase : public Acts::PlanarBounds
- #include <Acts/Surfaces/ConvexPolygonBounds.hpp>
base class for convex polygon bounds
This class serves as a base class for the actual bounds class. The only deriving type is the templated
ConvexPolygonBounds
.Subclassed by Acts::ConvexPolygonBounds< N >, Acts::ConvexPolygonBounds< PolygonDynamic >
Public Functions
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostream to be written into
-
virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
virtual std::ostream &toStream(std::ostream &sl) const final
-
struct CovarianceCache
- #include <Acts/Propagator/CovarianceTransport.hpp>
Helper struct holding the necessary cache for the Covariance transport in various parametrisations.
Public Functions
-
CovarianceCache() = default
Defaulted constructor, gives invalid cache.
-
CovarianceCache(const GeometryContext &gctx, const Surface &surface, const Vector3 position, const BoundVector &boundParameters, const BoundSymMatrix &boundCovariance)
Constructor from bound & surface.
This constructor will set the variant covariance type to a bound matrix, remember the surface & establish the jacobian between bound and free parametrisation.
- Parameters
gctx – The current geometry context
surface – The surface of the bound representation
position – The position of the representaiton
boundParameters – The bound parameters at the surface
boundCovariance – The bound covariance to be propagated
-
CovarianceCache(const Vector3 position, const Vector3 &direction, const BoundSymMatrix &boundCovariance)
Constructor from curvilinear.
This constructor will set the variant covariance type to a bound matrix, remember the surface & establish the jacobian between bound and free parametrisation.
- Parameters
position – The position of the representation
direction – The direction of at the representation
boundCovariance – The bound covariance to be propagated
-
CovarianceCache(const FreeVector &freeParameters, const FreeSymMatrix &freeCovariance)
Construction from free.
- Parameters
freeParameters – The free parameters
freeCovariance – The free covariance to be propagated
Public Members
-
std::optional<ActsMatrix<8, 7>> anglesToDirectionJacobian = std::nullopt
Options for starting from free.
-
bool applyTransport = false
Internal cache state, indicates correct setup.
-
const Surface *atSurface = nullptr
Internal cache state, at surface indication.
-
std::optional<BoundToFreeMatrix> boundToFreeJacobian = std::nullopt
Optional for starting from bound or curvilinear.
-
VariantCovariance covariance
Variant: the currently held covariance.
-
std::optional<ActsMatrix<7, 8>> directionToAnglesJacobian = std::nullopt
-
FreeVector freeToPathDerivatives = FreeVector::Zero()
Non-variant: the free derivatives.
-
FreeMatrix freeTransportJacobian = FreeMatrix::Identity()
Non-variant: the free transport jacobian.
-
CovarianceCache() = default
-
class CuboidVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/CuboidVolumeBounds.hpp>
Bounds for a cubical Volume, the orientedSurfaces(…) method creates a vector of 6 surfaces:
BoundarySurfaceFace [index]:
negativeFaceXY [0] : Rectangular Acts::PlaneSurface, parallel to \( xy \) plane at negative \( z \)
positiveFaceXY [1] : Rectangular Acts::PlaneSurface, parallel to \( xy \) plane at positive \( z \)
negativeFaceXY [2] : Rectangular Acts::PlaneSurface, attached to \( yz \) plane at negative \( x \)
positiveFaceXY [3] : Rectangular Acts::PlaneSurface, attached to \( yz \) plane at negative \( x \)
negativeFaceXY [4] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at negative \( y \)
positiveFaceXY [5] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at positive \( y \)
Public Types
-
enum BoundValues
for streaming and access
Values:
-
enumerator eHalfLengthX
-
enumerator eHalfLengthY
-
enumerator eHalfLengthZ
-
enumerator eSize
-
enumerator eHalfLengthX
Public Functions
-
CuboidVolumeBounds() = delete
-
CuboidVolumeBounds(double halex, double haley, double halez) noexcept(false)
Constructor - the box boundaries.
- Parameters
halex – is the half length of the cube in x
haley – is the half length of the cube in y
halez – is the half length of the cube in z
-
inline CuboidVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from a fixed size array.
- Parameters
values – iw the bound values
-
CuboidVolumeBounds(const CuboidVolumeBounds &bobo)
Copy Constructor.
- Parameters
bobo – is the source volume bounds to be copied
-
~CuboidVolumeBounds() override = default
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
inline virtual bool inside(const Vector3 &pos, double tol = 0.) const override
This method checks if position in the 3D volume frame is inside the cylinder.
- Parameters
pos – is the position in volume frame to be checked
tol – is the absolute tolerance to be applied
-
CuboidVolumeBounds &operator=(const CuboidVolumeBounds &bobo)
Assignment operator.
- Parameters
bobo – is the source volume bounds to be assigned
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const override
Output Method for std::ostream.
- Parameters
sl – is ostream operator to be dumped into
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
class CuboidVolumeBuilder : public Acts::ITrackingVolumeBuilder
- #include <Acts/Geometry/CuboidVolumeBuilder.hpp>
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.
Public Functions
-
CuboidVolumeBuilder() = default
Default constructor without a configuration.
-
inline CuboidVolumeBuilder(Config &cfg)
Constructor that sets the config.
- Parameters
cfg – [in] Configuration of the detector
-
std::pair<double, double> binningRange(const GeometryContext &gctx, const VolumeConfig &cfg) const
This function evaluates the minimum and maximum of the binning as given by the configurations of the surfaces and layers.
The ordering depends on the binning value specified in the configuration of the volume.
- Parameters
gctx – [in] the geometry context for this building
cfg – [in] Container with the given surfaces and layers
- Returns
Pair containing the minimum and maximum along the binning direction
-
std::shared_ptr<const Layer> buildLayer(const GeometryContext &gctx, LayerConfig &cfg) const
This function creates a layer with a surface encaspulated with a given configuration.
The surface gets a detector element attached if the template parameter is non-void.
- Parameters
gctx – [in] the geometry context for this building
cfg – [inout] Configuration of the layer and the surface
- Returns
Pointer to the created layer
-
std::shared_ptr<const Surface> buildSurface(const GeometryContext &gctx, const SurfaceConfig &cfg) const
This function creates a surface with a given configuration.
A detector element is attached if the template parameter is non-void.
- Parameters
gctx – [in] the geometry context for this building
cfg – [in] Configuration of the surface
- Returns
Pointer to the created surface
-
std::shared_ptr<TrackingVolume> buildVolume(const GeometryContext &gctx, VolumeConfig &cfg) const
This function creates a TrackingVolume with a configurable number of layers and surfaces.
Each surface gets a detector element attached if the template parameter is non-void.
- Parameters
gctx – [in] the geometry context for this building
cfg – [inout] Configuration of the TrackingVolume
- Returns
Pointer to the created TrackingVolume
-
inline void setConfig(Config &cfg)
Setter of the config.
- Parameters
cfg – [in] Configuration that is set
-
void sortVolumes(std::vector<std::pair<TrackingVolumePtr, Vector3>> &tapVec, BinningValue bValue) const
This function builds a world TrackingVolume based on a given configuration.
- Parameters
gctx – [in] the geometry context for this building
- Returns
Pointer to the created TrackingGeometry
-
struct Config
- #include <Acts/Geometry/CuboidVolumeBuilder.hpp>
This struct stores the configuration of the tracking geometry.
Public Members
-
std::vector<VolumeConfig> volumeCfg = {}
-
std::vector<VolumeConfig> volumeCfg = {}
-
struct LayerConfig
- #include <Acts/Geometry/CuboidVolumeBuilder.hpp>
This struct stores the data for the construction of a PlaneLayer.
Public Members
-
bool active = false
-
size_t binsY = 1
-
size_t binsZ = 1
-
std::pair<double, double> envelopeX = {0, 0}
-
std::optional<RotationMatrix3> rotation = {std::nullopt}
-
std::vector<SurfaceConfig> surfaceCfg
-
std::vector<std::shared_ptr<const Surface>> surfaces
-
bool active = false
-
struct SurfaceConfig
- #include <Acts/Geometry/CuboidVolumeBuilder.hpp>
This struct stores the data for the construction of a single PlaneSurface.
Public Members
-
std::function<DetectorElementBase*(const Transform3&, std::shared_ptr<const RectangleBounds>, double)> detElementConstructor
-
Vector3 position
-
std::shared_ptr<const RectangleBounds> rBounds = nullptr
-
RotationMatrix3 rotation = RotationMatrix3::Identity()
-
std::shared_ptr<const ISurfaceMaterial> surMat = nullptr
-
double thickness = 0.
-
std::function<DetectorElementBase*(const Transform3&, std::shared_ptr<const RectangleBounds>, double)> detElementConstructor
-
struct VolumeConfig
- #include <Acts/Geometry/CuboidVolumeBuilder.hpp>
This struct stores the data for the construction of a cuboid TrackingVolume with a given number of PlaneLayers.
Public Members
-
std::vector<LayerConfig> layerCfg
-
std::vector<std::shared_ptr<const Layer>> layers
-
Vector3 length
-
std::string name = "Volume"
-
Vector3 position
-
std::vector<std::shared_ptr<TrackingVolume>> trackingVolumes
-
std::vector<VolumeConfig> volumeCfg
-
std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr
-
std::vector<LayerConfig> layerCfg
-
CuboidVolumeBuilder() = default
-
class CutoutCylinderVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/CutoutCylinderVolumeBounds.hpp>
Class which implements a cutout cylinder.
This shape is bascially a cylinder, with another, smaller cylinder subtracted from the center. ——————— rmax | | | |———| | rmed | | | | —— —— rmin — hlZc — ——— hlZ —-—
Public Types
-
enum BoundValues
for streaming and access
Values:
-
enumerator eMinR
-
enumerator eMedR
-
enumerator eMaxR
-
enumerator eHalfLengthZ
-
enumerator eHalfLengthZcutout
-
enumerator eSize
-
enumerator eMinR
Public Functions
-
CutoutCylinderVolumeBounds() = delete
-
inline CutoutCylinderVolumeBounds(double rmin, double rmed, double rmax, double hlZ, double hlZc) noexcept(false)
Constructor from defining parameters.
- Parameters
rmin – Minimum radius at the “choke points”
rmed – The medium radius (outer radius of the cutout)
rmax – The outer radius of the overall shape
hlZ – The longer halflength of the shape
hlZc – The cutout halflength of the shape
-
inline CutoutCylinderVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from a fixed size array.
- Parameters
values – The bound values
-
~CutoutCylinderVolumeBounds() override = default
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector3 &gpos, double tol = 0) const override
Inside method to test whether a point is inside the shape.
- Parameters
gpos – The point to test
tol – The tolerance to test with
- Returns
Whether the point is inside or not.
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const override
Write information about this instance to an outstream.
- Parameters
sl – The outstream
- Returns
The outstream
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
enum BoundValues
-
class CylinderBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/CylinderBounds.hpp>
Bounds for a cylindrical Surface.
These bounds may be used for a CylinderSurface In case of bounds for a StraightLineSurface the radius determines the radius within a localPosition is regarded as inside bounds.
CylinderBounds also enhance the possibility of a cylinder segment with an opening angle \( 2\cdot\phi_{half}\) around an average \( \phi \) angle \( \phi_{ave} \).
CylinderBounds also supports beveled sides defined by an angle. Different angles can be defined on both sides of the cylinder. A postive angle is defined as “extruding” from the defined Zlength, while a negative angle is “intruding” on the Zlength.
- - +
\ | / \ | / \ | / \ | / |/______________|/ 2 * ZhalfLength
Public Types
-
enum BoundValues
Values:
-
enumerator eR
-
enumerator eHalfLengthZ
-
enumerator eHalfPhiSector
-
enumerator eAveragePhi
-
enumerator eBevelMinZ
-
enumerator eBevelMaxZ
-
enumerator eSize
-
enumerator eR
Public Functions
-
CylinderBounds() = delete
-
inline CylinderBounds(double r, double halfZ, double halfPhi = M_PI, double avgPhi = 0., double bevelMinZ = 0., double bevelMaxZ = 0.) noexcept(false)
Constructor - full cylinder.
- Parameters
r – The radius of the cylinder
halfZ – The half length in z
halfPhi – The half opening angle
avgPhi – (optional) The phi value from which the opening angle spans
bevelMinZ – (optional) The bevel on the negative z side
bevelMaxZ – (optional) The bevel on the positive z sid The bevel on the positive z side
-
inline CylinderBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array.
- Parameters
values – The parameter values
-
~CylinderBounds() override = default
-
inline bool coversFullAzimuth() const
Returns true for full phi coverage.
-
std::vector<Vector3> createCircles(const Transform3 trans, size_t lseg) const
Create the bows/circles on either side of the cylinder.
- Parameters
trans – is the global transform
lseg – are the numbero if phi segments
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
bool inside3D(const Vector3 &position, const BoundaryCheck &bcheck = true) const
Specialized method for CylinderBounds that checks if a global position is within the cylinder cover.
- Parameters
position – is the position in the cylinder frame
bcheck – is the boundary check directive
- Returns
boolean indicator for operation success
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
class CylinderLayer : public Acts::CylinderSurface, public Acts::Layer
- #include <Acts/Geometry/CylinderLayer.hpp>
Class to describe a cylindrical detector layer for tracking, it inhertis from both, Layer base class and CylinderSurface class.
Public Functions
-
CylinderLayer(const CylinderLayer &cla) = delete
-
CylinderLayer() = delete
-
~CylinderLayer() override = default
-
CylinderLayer &operator=(const CylinderLayer&) = delete
-
virtual const CylinderSurface &surfaceRepresentation() const override
Transforms the layer into a Surface representation This is for positioning and extrapolation.
-
virtual CylinderSurface &surfaceRepresentation() override
Public Static Functions
Factory for shared Layer pointer create a shared, fully deployed CylinderLayer.
- Parameters
transform – is the 3D transform that places the layer in 3D space
cbounds – are the cylindrical bounds of the layer
surfaceArray – is the Binned Array that holds the sensitive surfaces
thickness – is the layer thickness (along the normal)
ad – is the approach descriptor for approaching the layer
laytyp – is the layer type
- Returns
The return object is a shared poiter to the layer.
-
CylinderLayer(const CylinderLayer &cla) = delete
-
class CylinderSurface : public Acts::Surface
- #include <Acts/Surfaces/CylinderSurface.hpp>
Class for a CylinderSurface in the TrackingGeometry.
It inherits from Surface.
The cylinder surface has a special role in the TrackingGeometry, since it builds the surfaces of all TrackingVolumes at container level for a cylindrical tracking geometry.
Subclassed by Acts::CylinderLayer
Public Functions
-
CylinderSurface() = delete
-
~CylinderSurface() override = default
-
virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const final
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. the alignment parameters
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const final
The binning position method - is overloaded for r-type binning.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the type of global binning to be done
- Returns
is the global position to be used for binning
-
virtual const CylinderBounds &bounds() const final
This method returns the CylinderBounds by reference.
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const final
Global to local transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position to be transformed
momentum – is the global momentum (ignored in this operation)
tolerance – optional tolerance within which a point is considered valid on surface
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck) const final
Straight line intersection schema from position/direction.
If possible returns both solutions for the cylinder
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position to start from
direction – The direction at start
bcheck – the Boundary Check
- Returns
SurfaceIntersection object (contains intersection & surface)
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const final
Local to global transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position to be transformed
momentum – is the global momentum (ignored in this operation)
- Returns
The global position by value
-
virtual std::string name() const override
Return method for properly formatted output string.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final
Return method for surface normal information.
Note
for a Cylinder a local position is always required for the normal vector
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local postion for which the normal vector is requested
- Returns
normal vector at the local position by value
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final
Return method for surface normal information.
Note
for a Cylinder a local position is always required for the normal vector
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global postion for which the normal vector is requested
- Returns
normal vector at the global position by value
-
CylinderSurface &operator=(const CylinderSurface &other)
Assignment operator.
- Parameters
other – is the source cylinder for the copy
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final
Path correction due to incident of the track.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position as a starting point
direction – is the global momentum at the starting point
- Returns
is the correction factor due to incident
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const override
Return a Polyhedron for a cylinder.
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, it represents the full 2*M_PI coverange, if lseg is set to 1 only the extrema are given
- Returns
A list of vertices and a face/facett description of it
-
virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum) const final
Return the measurement frame - this is needed for alignment, in particular The measurement frame of a cylinder is the tangential plane at a given position.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the position where the measurement frame is defined
momentum – is the momentum vector (ignored)
- Returns
rotation matrix that defines the measurement frame
-
virtual Vector3 rotSymmetryAxis(const GeometryContext &gctx) const
Return method for the rotational symmetry axis.
- Parameters
gctx – The current geometry context object, e.g. alignment
- Returns
the z-Axis of transform
-
virtual SurfaceType type() const override
Return the surface type.
-
CylinderSurface() = delete
-
class CylinderVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/CylinderVolumeBounds.hpp>
[0] and [1] at positive \( \phi \)
Bounds for a cylindrical Volume, the orientedSurfaces(..) method creates a vector of up to 6 surfaces:
case A) 3 Surfaces (full cylindrical tube): BoundarySurfaceFace [index]:
negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at negative \( z\)
positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at positive \( z\)
cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume
case B) 4 Surfaces (tube with inner and outer radius): BoundarySurfaceFace [index]:
negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at negative \( z\)
positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at positive \( z\)
tubeOuterCover [2] : Acts::CylinderSurface with \( r = r_{outer} \)
tubeInnerCover [3] : Acts::CylinderSurface with \( r = r_{inner} \)
case C) 6 Surfaces (sectoral tube with inner and outer radius): BoundarySurfaceFace [index]:
negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}>0\) and \( \phi < \pi \), parallel to \( xy \) plane at negative \(z\)
positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at positive \(z\)
tubeSectorOuterCover [2] : Acts::CylinderSurface with \( r = r_{outer}\)
tubeSectorInnerCover [3] : Acts::CylinderSurface with \( r = r_{inner} \)
tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to [0] and [1] at negative \( \phi \)
tubeSectorNegativePhi [5] :
Public Types
-
enum BoundValues
for streaming and access
Values:
-
enumerator eMinR
-
enumerator eMaxR
-
enumerator eHalfLengthZ
-
enumerator eHalfPhiSector
-
enumerator eAveragePhi
-
enumerator eBevelMinZ
-
enumerator eBevelMaxZ
-
enumerator eSize
-
enumerator eMinR
Public Functions
-
CylinderVolumeBounds() = delete
-
inline CylinderVolumeBounds(double rmin, double rmax, double halfz, double halfphi = M_PI, double avgphi = 0., double bevelMinZ = 0., double bevelMaxZ = 0.) noexcept(false)
Constructor.
- Parameters
rmin – The inner radius of the cylinder
rmax – The outer radius of the cylinder
halfz – The half length in z
halfphi – The half lopening angle
avgphi – The average phi value
bevelMinZ – The bevel angle, in radians, for the negative side
bevelMaxZ – The bevel angle, in radians, for the positive side
-
inline CylinderVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from a fixed size array.
- Parameters
values – The bound values
-
CylinderVolumeBounds(const CylinderBounds &cBounds, double thickness) noexcept(false)
Constructor - extruded from cylinder bounds and thickness.
- Parameters
cBounds – the cylinder bounds
thickness – of the extrusion
-
CylinderVolumeBounds(const RadialBounds &rBounds, double thickness) noexcept(false)
Constructor - extruded from radial bounds and thickness.
- Parameters
rBounds – the Radial bounds
thickness –
-
CylinderVolumeBounds(const CylinderVolumeBounds &cylbo) = default
Copy Constructor.
- Parameters
cylbo – is the source cylinder volume bounds for the copy
-
~CylinderVolumeBounds() override = default
-
inline virtual double binningBorder(BinningValue bValue) const override
Binning borders in double.
- Parameters
bValue – is the type used for the binning
-
inline virtual Vector3 binningOffset(BinningValue bValue) const override
Binning offset - overloaded for some R-binning types.
- Parameters
bValue – is the type used for the binning
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
inline virtual bool inside(const Vector3 &pos, double tol = 0.) const override
This method checks if position in the 3D volume frame is inside the cylinder.
- Parameters
pos – is a global position to be checked
tol – is the tolerance for the check
-
CylinderVolumeBounds &operator=(const CylinderVolumeBounds &cylbo) = default
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const override
Output Method for std::ostream.
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
class CylinderVolumeBuilder : public Acts::ITrackingVolumeBuilder
- #include <Acts/Geometry/CylinderVolumeBuilder.hpp>
A volume builder to be used for building a concentrical cylindrical volumes.
a) configured volume
b) wrapping around a cylindrical/disk layer config
All are optionally wrapped around a given volume which has to by a cylinder volume and which has to be center at z == 0
To receive the tracking volume it is possible to also hand over a triple of layers, which is a C++ tuple of three pointers to layer vectors (defined in the ITrackingVolumeBuilder). This functionality is needed for a possible translation of an geometry existing in another format. The first entry represents the layers of the negative endcap, the second the layers of the barrel and the third the layers of the positive endcap. If the one of these pointers is a nullptr no layers will be created for this volume
For the endcap region it is possible to check for a ring layout, in which case an attempt to split into individual ring volumes is done
Public Functions
-
CylinderVolumeBuilder(const Config &cvbConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("CylinderVolumeBuilder", Logging::INFO))
Constructor.
- Parameters
cvbConfig – [in] is the configuraiton struct to steer the builder
logger – [in] logging instance
-
~CylinderVolumeBuilder() override
Destructor.
-
VolumeConfig analyzeContent(const GeometryContext &gctx, const LayerVector &lVector, const MutableTrackingVolumeVector &mtvVector) const
Analyze the config to gather needed dimension.
- Parameters
gctx – [in] the geometry context for this building
lVector – [in] is the vector of layers that are parsed
mtvVector – [in] Vector of mutable tracking volumes to analyze
- Returns
a VolumeConfig representing this layer
-
inline Config getConfiguration() const
Get configuration method.
Return the configuration object.
- Returns
a copy of the config object
-
void setConfiguration(const Config &cvbConfig)
Set configuration method.
- Parameters
cvbConfig – [in] is the new configuration to be set
-
void setLogger(std::unique_ptr<const Logger> newLogger)
set logging instance
- Parameters
newLogger – [in] is the logging istance to be set
-
virtual MutableTrackingVolumePtr trackingVolume(const GeometryContext &gctx, TrackingVolumePtr existingVolume = nullptr, VolumeBoundsPtr externalBounds = nullptr) const override
CylinderVolumeBuilder main call method.
- Parameters
gctx – [in] geometry context for which this cylinder volume is built
existingVolume – [in] is an (optional) volume to be included
externalBounds – [in] are (optional) external confinement constraints
- Returns
a mutable pointer to a new TrackingVolume which includes the optionally provided exisitingVolume consistently for further processing
-
struct Config
- #include <Acts/Geometry/CylinderVolumeBuilder.hpp>
Nested configuration struct for this CylinderVolumeBuilder.
Public Members
-
std::array<std::shared_ptr<const ISurfaceMaterial>, 6> boundaryMaterial{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}
—————–— MB (outer [1]) ————— | MB [2] NEC MB [3] | B | MB [4] PEC MB [5] | —————–— MB (inner [0]) —————
-
bool buildToRadiusZero = false
Build the volume to the beam line.
-
bool checkRingLayout = false
Check for endcap ring layout.
-
std::shared_ptr<const IConfinedTrackingVolumeBuilder> ctVolumeBuilder = nullptr
Builder to construct confined volumes within the volume.
-
std::shared_ptr<const ILayerBuilder> layerBuilder = nullptr
Builder to construct layers within the volume.
-
std::pair<double, double> layerEnvelopeR = {1. * UnitConstants::mm, 1. * UnitConstants::mm}
Additional envelope in R to create rMin, rMax.
-
double layerEnvelopeZ = 1. * UnitConstants::mm
the additional envelope in Z to create zMin, zMax
-
double ringTolerance = 0 * UnitConstants::mm
Tolerance for endcap ring association.
-
std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr
The trackign volume helper for construction.
-
std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr
The world material.
-
std::string volumeName = ""
The string based indenfication.
-
int volumeSignature = -1
Volume signature.
-
std::array<std::shared_ptr<const ISurfaceMaterial>, 6> boundaryMaterial{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}
-
class CylinderVolumeHelper : public Acts::ITrackingVolumeHelper
- #include <Acts/Geometry/CylinderVolumeHelper.hpp>
The concrete implementation for cylindrical TrackingVolume objects of the ITrackingVolumeCreator interface.
Public Functions
-
CylinderVolumeHelper(const Config &cvhConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("CylinderVolumeHelper", Logging::INFO))
Constructor.
- Parameters
cvhConfig – is the configuration struct for this builder
logger – logging instance
-
~CylinderVolumeHelper() override = default
-
virtual MutableTrackingVolumePtr createContainerTrackingVolume(const GeometryContext &gctx, const TrackingVolumeVector &volumes) const override
Create a container volumes from sub volumes, input volumes are ordered in R or Z by convention.
- Parameters
gctx – [in] the geometry context for this building
volumes – the volumes to be contained
- Returns
shared pointer to a new TrackingVolume
Create a gap volume from dimensions and.
Note
this TrackingVolume is restricted to Translation only
- Parameters
gctx – [in] the geometry context for this building
mtvVector – Vector of confined TrackingVolumes
volumeMaterial – dense material properties for this TrackingVolume
rMin – minimum radius
rMax – maximum radius
zMin – minimum z
zMax – maximum z
materialLayers – number of material layers (aequidistant binning)
cylinder – type of layers
volumeName – volume name to be given
- Returns
shared pointer to a new TrackingVolume
Create a gap volume from dimensions and.
- Parameters
gctx – [in] the geometry context for this building
mtvVector – Vector of confined TrackingVolumes
volumeMaterial – dense material properties for this TrackingVolume
rMin – minimum radius
rMax – maximum radius
zMin – minimum z
zMax – maximum z
layerPositions – custom layer positions
cylinder – type of layers
volumeName – : volume name to be given
bType – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
Create a TrackingVolume* from a set of layers and (optional) parameters.
- Parameters
gctx – is the geometry context for witch the volume is built
layers – vector of static layers confined by the TrackingVolume if no bounds or HepTransform is given, they define the size together with the volume enevlope parameters
volumeMaterial – material properties for this TrackingVolume
volumeBounds – confinement of this TrackingVolume
mtvVector – (optiona) Vector of confined TrackingVolumes
transform – (optional) placement of this TrackingVolume
volumeName – volume name to be given
bType – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
Create a TrackingVolume* from a set of layers and (optional) parameters.
- Parameters
gctx – is the geometry context for witch the volume is built
layers – vector of static layers confined by the TrackingVolume if no bounds or HepTransform is given, they define the size together with the volume enevlope parameters
volumeMaterial – material properties for this TrackingVolume
mtvVector – Vector of confined TrackingVolumes
rMin – minimum radius
rMax – maximum radius
zMin – minimum z
zMax – maximum z
volumeName – volume name to be given
bType – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
-
inline Config getConfiguration() const
Get configuration method.
-
void setConfiguration(const Config &cvhConfig)
Set configuration method.
- Parameters
cvhConfig – is the configurtion struct assigned
-
void setLogger(std::unique_ptr<const Logger> newLogger)
Set logging instance.
- Parameters
newLogger – is the logger isntance to be set
-
struct Config
- #include <Acts/Geometry/CylinderVolumeHelper.hpp>
Nested configuration struct for this CylinderVolumeHelper.
Public Members
-
std::shared_ptr<const ILayerArrayCreator> layerArrayCreator = nullptr
a tool for coherent LayerArray creation
-
int passiveLayerPhiBins = 1
bins in phi for the passive layer
-
int passiveLayerRzBins = 100
bins in r/z for the passive layer
-
double passiveLayerThickness = 1
thickness of passive layers
-
std::shared_ptr<const ITrackingVolumeArrayCreator> trackingVolumeArrayCreator = nullptr
Helper Tool to create TrackingVolume.
-
std::shared_ptr<const ILayerArrayCreator> layerArrayCreator = nullptr
-
CylinderVolumeHelper(const Config &cvhConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("CylinderVolumeHelper", Logging::INFO))
-
class DD4hepDetectorElement : public Acts::TGeoDetectorElement
- #include <Acts/Plugins/DD4hep/DD4hepDetectorElement.hpp>
DetectorElement class implementation for DD4hep geometry.
DetectorElement plugin for DD4hep detector elements. DD4hep is based on TGeo shapes, therefore the DD4hepDetectorElement inherits from TGeoDetectorElement. The full geometrical information is provided by the TGeoDetectorElement. The DD4hepDetectorElement extends the TGeoDetectorElement by containing a segmentation for the readout.
Public Types
-
using ContextType = GeometryContext
Broadcast the context type.
Public Functions
Constructor.
Example options are:
”XYZ” -> identical frame definition (default value)
”YZX” -> node y axis is tracking x axis, etc.
”XzY” -> negative node z axis is tracking y axis, etc.
Note
In the translation from a 3D geometry (TGeo) which only knows tubes to a 2D geometry (Tracking geometry) a distinction if the module should be described as a cylinder or a disc surface needs to be done. Since this information can not be taken just from the geometry description (both can be described as TGeoTubeSeg), one needs to set the flag ‘isDisc’ in case a volume with shape
TGeoTubeSeg
should be translated to a disc surface. Per default it will be translated into a cylindrical surface.- Parameters
scalor – is the scale factor for unit conversion if needed
isDisc – in case the sensitive detector module should be translated as disc (e.g. for endcaps) this flag should be set to true
digitizationModule – Optional digitization configuration for the element
material – Optional material of detector element
detElement – The DD4hep DetElement which should be linked to a surface
axes – is the axis orientation with respect to the tracking frame it is a string of the three characters x, y and z (standing for the three axes) There is a distinction between capital and lower case characters :
capital -> positive orientation of the axis
lower case -> negative oriantation of the axis
-
~DD4hepDetectorElement() override = default
-
using ContextType = GeometryContext
-
class DD4hepLayerBuilder : public Acts::ILayerBuilder
- #include <Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp>
build layers of one cylinder-endcap setup from DD4hep input
This class is an implementation of the Acts::ILayerBuilder, creating the central (layers of barrel), the negative and positive layers (layers of endcaps) of one hierarchy (e.g. PixelDetector, StripDetector,…) with input from DD4hep.
Public Functions
-
DD4hepLayerBuilder(const Acts::DD4hepLayerBuilder::Config &config, std::unique_ptr<const Logger> logger)
Constructor.
- Parameters
config – is the configuration struct
logger – is the logging instance
-
~DD4hepLayerBuilder() override
Destructor.
-
virtual const LayerVector centralLayers(const GeometryContext &gctx) const final
LayerBuilder interface method.
- Parameters
gctx – the geometry context for this build call
- Returns
the layers at the central sector
-
inline Config getConfiguration() const
get the configuration object
-
inline virtual const std::string &identification() const final
Name identification.
- Returns
the string based identification of this configuration
-
virtual const LayerVector negativeLayers(const GeometryContext &gctx) const final
LayerBuilder interface method.
- Parameters
gctx – the geometry context for this build call
- Returns
the layers at negative side
-
virtual const LayerVector positiveLayers(const GeometryContext &gctx) const final
LayerBuilder interface method.
- Parameters
gctx – the geometry context for this build call
- Returns
the layers at positive side
-
void setConfiguration(const Config &config)
set the configuration object
- Parameters
config – is the configuration struct
-
void setLogger(std::unique_ptr<const Logger> logger)
set logging instance
-
struct Config
- #include <Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp>
nested configuration struct for steering of the layer builder
Public Members
-
BinningType bTypePhi = equidistant
the binning type of the contained surfaces in phi (equidistant/arbitrary)
-
BinningType bTypeR = equidistant
the binning type of the contained surfaces in r (equidistant/arbitrary)
-
BinningType bTypeZ = equidistant
the binning type of the contained surfaces in z (equidistant/arbitrary)
-
std::vector<dd4hep::DetElement> centralLayers
the DD4hep::DetElements of the layers of the central volume (barrel)
Note
if the current volume has no layers this parameter will not be set
-
std::string configurationName = "undefined"
string based identification
-
double defaultThickness = UnitConstants::fm
In case no surfaces (to be contained by the layer) are handed over, the layer thickness will be set to this value.
- Attention
The default thickness should be set thin enough that no touching or overlapping with the next layer can happen.
Note
Layers containing surfaces per default are not allowed to be attached to each other (navigation will bail 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.
-
std::shared_ptr<const LayerCreator> layerCreator = nullptr
layer creator which is internally used to build layers
-
std::vector<dd4hep::DetElement> negativeLayers
the DD4hep::DetElements of the layers of the negative volume (negative endcap)
Note
if the current volume has no endcaps or no layers this parameter will not be set
-
std::vector<dd4hep::DetElement> positiveLayers
the DD4hep::DetElements of the layers of the positive volume (positive endcap)
Note
if the current volume has no endcaps or no layers this parameter will not be set
-
BinningType bTypePhi = equidistant
-
DD4hepLayerBuilder(const Acts::DD4hepLayerBuilder::Config &config, std::unique_ptr<const Logger> logger)
-
class DD4hepVolumeBuilder : public Acts::IConfinedTrackingVolumeBuilder
- #include <Acts/Plugins/DD4hep/DD4hepVolumeBuilder.hpp>
build confined TrackingVolumes of one cylinder setup from DD4hep input.
This class is an implementation of the Acts::IConfinedTrackingVolumeBuilder, creating the central (volumes of barrel), the negative and positive volumes (volumes of endcaps) of one hierarchy (e.g. ECal, HCal…) with input from DD4hep.
Public Functions
-
DD4hepVolumeBuilder(const Acts::DD4hepVolumeBuilder::Config &config, std::unique_ptr<const Logger> logger)
Constructor.
- Parameters
config – [in] is the configuration struct
logger – [in] is the logging instance
-
~DD4hepVolumeBuilder() override
Destructor.
-
virtual MutableTrackingVolumeVector centralVolumes() const final
Builder method for cylindrical, confined volume.
- Returns
The vector of TrackingVolumes at the central sector
-
inline Config getConfiguration() const
Get the configuration object.
- Returns
The used configuration struct
-
inline virtual const std::string &identification() const final
Name identification.
- Returns
The string based identification of this configuration
-
void setConfiguration(const Config &config)
Set the configuration object.
- Parameters
config – [in] is the configuration struct
-
void setLogger(std::unique_ptr<const Logger> logger)
Set logging instance.
- Parameters
logger – [in] Logger in use
-
struct Config
- #include <Acts/Plugins/DD4hep/DD4hepVolumeBuilder.hpp>
Nested configuration struct for steering of the volume builder.
Public Members
-
std::vector<dd4hep::DetElement> centralVolumes
Vector of central confined volumes.
-
std::string configurationName = "undefined"
string based identification
-
std::vector<dd4hep::DetElement> centralVolumes
-
DD4hepVolumeBuilder(const Acts::DD4hepVolumeBuilder::Config &config, std::unique_ptr<const Logger> logger)
-
template<typename>
class Delegate - #include <Acts/Utilities/Delegate.hpp>
-
template<typename R, typename ...Args>
class Delegate<R(Args...)> - #include <Acts/Utilities/Delegate.hpp>
Delegate type that allows type erasure of a callable without allocation and with a single level of indirection.
This type can support:
a free function pointer
a pointer to a member function alongside an instance pointer
Note
Delegate
does not assume ownership of the instance. You need to ensure that the lifetime of the callable instance is longer than that of theDelegate
.Note
Currently
Delegate
only supports callables that areconst
- Template Parameters
R – Return type of the function signature
Args – Types of the arguments of the function signatures
Public Functions
-
Delegate() = default
-
inline Delegate(function_type callable)
Constructor with an explicit runtime callable.
Note
The function signature requires the first argument of the callable is
const void*
. i.e. if the signature of the delegate isvoid(int)
, the callable’s signature has to bevoid(const void*, int)
.- Parameters
callable – The runtime value of the callable
-
template<typename Callable, typename = isNoFunPtr<Callable>>
inline Delegate(Callable &callable) Constructor with a possibly stateful function object.
Note
Delegate
does not assume owner ship overcallable
. You need to ensure it’s lifetime is longer than that ofDelegate
.- Template Parameters
Callable – Type of the callable
- Parameters
callable – The callable (function object or lambda)
-
template<typename Callable, typename = isNoFunPtr<Callable>>
Delegate(Callable&&) = delete Constructor from rvalue reference is deleted, should catch construction with temporary objects and thus invalid pointers.
-
template<auto Callable>
inline void connect() Connect a free function pointer.
Note
The function pointer must be
constexpr
forDelegate
to accept it- Template Parameters
Callable – The compile-time free function pointer
-
template<typename Callable, typename = isNoFunPtr<Callable>>
inline void connect(Callable &callable) Assignment operator with possibly stateful function object.
Note
Delegate
does not assume owner ship overcallable
. You need to ensure it’s lifetime is longer than that ofDelegate
.- Template Parameters
Callable – Type of the callable
- Parameters
callable – The callable (function object or lambda)
-
template<typename Callable, typename = isNoFunPtr<Callable>>
void connect(Callable&&) = delete Connection with rvalue reference is deleted, should catch assignment from temporary objects and thus invalid pointers.
-
inline void connect(function_type callable)
Connect anything that is assignable to the function pointer.
Note
The function signature requires the first argument of the callable is
const void*
. i.e. if the signature of the delegate isvoid(int)
, the callable’s signature has to bevoid(const void*, int)
.- Parameters
callable – The runtime value of the callable
-
template<auto Callable, typename Type>
inline void connect(const Type *instance) Connect a member function to be called on an instance.
Note
Delegate
does not assume owner ship overinstance
. You need to ensure it’s lifetime is longer than that ofDelegate
.- Template Parameters
Callable – The compile-time member function pointer
Type – The type of the instance the member function should be called on
- Parameters
instance – The instance on which the member function pointer should be called on
-
inline bool connected() const
Return whether this delegate is currently connected.
- Returns
True if this delegate is connected
-
inline void disconnect()
Disconnect this delegate, meaning it cannot be called anymore.
-
inline operator bool() const
Return whether this delegate is currently connected.
- Returns
True if this delegate is connected
-
inline return_type operator()(Args... args) const
The call operator that exposes the functionality of the
Delegate
type.- Parameters
args – The arguments to call the contained function with
- Returns
Return value of the contained function
-
inline void operator=(function_type callable)
Assignment operator with an explicit runtime callable.
Note
The function signature requires the first argument of the callable is
const void*
. i.e. if the signature of the delegate isvoid(int)
, the callable’s signature has to bevoid(const void*, int)
.- Parameters
callable – The runtime value of the callable
-
template<typename Callable, typename = isNoFunPtr<Callable>>
inline void operator=(Callable &callable) Assignment operator with possibly stateful function object.
Note
Delegate
does not assume owner ship overcallable
. You need to ensure it’s lifetime is longer than that ofDelegate
.- Template Parameters
Callable – Type of the callable
- Parameters
callable – The callable (function object or lambda)
-
template<typename Callable, typename = isNoFunPtr<Callable>>
void operator=(Callable&&) = delete Assignment operator from rvalue reference is deleted, should catch assignment from temporary objects and thus invalid pointers.
-
template<typename action_list_t = ActionList<>, typename aborter_list_t = AbortList<>>
struct DenseStepperPropagatorOptions : public Acts::PropagatorOptions<action_list_t, aborter_list_t> - #include <Acts/Propagator/DenseEnvironmentExtension.hpp>
Public Functions
-
DenseStepperPropagatorOptions(const DenseStepperPropagatorOptions<action_list_t, aborter_list_t> &dspo) = default
Copy Constructor.
-
inline DenseStepperPropagatorOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, LoggerWrapper logger_)
Constructor with GeometryContext.
- Parameters
gctx – The current geometry context object, e.g. alignment
mctx – The current magnetic fielc context object
logger_ – An instance of
LoggerWrapper
-
template<typename extended_aborter_list_t>
inline DenseStepperPropagatorOptions<action_list_t, extended_aborter_list_t> extend(extended_aborter_list_t aborters) const Expand the Options with extended aborters.
- Template Parameters
extended_aborter_list_t – Type of the new aborter list
- Parameters
aborters – The new aborter list to be used (internally)
Public Members
-
bool includeGgradient = true
Boolean flag for inclusion of d(dEds)d(q/p) into energy loss.
-
bool meanEnergyLoss = true
Toggle between mean and mode evaluation of energy loss.
-
double momentumCutOff = 0.
Cut-off value for the momentum in SI units.
-
DenseStepperPropagatorOptions(const DenseStepperPropagatorOptions<action_list_t, aborter_list_t> &dspo) = default
-
class DiamondBounds : public Acts::PlanarBounds
- #include <Acts/Surfaces/DiamondBounds.hpp>
Bounds for a double trapezoidal (“diamond”), planar Surface.
Public Types
-
enum BoundValues
Values:
-
enumerator eHalfLengthXnegY
-
enumerator eHalfLengthXzeroY
-
enumerator eHalfLengthXposY
-
enumerator eHalfLengthYneg
-
enumerator eHalfLengthYpos
-
enumerator eSize
-
enumerator eHalfLengthXnegY
Public Functions
-
DiamondBounds() = delete
-
inline DiamondBounds(double halfXnegY, double halfXzeroY, double halfXposY, double halfYneg, double halfYpos) noexcept(false)
Constructor for convex hexagon symmetric about the y axis.
- Parameters
halfXnegY – is the halflength in x at minimal y
halfXzeroY – is the halflength in x at y = 0
halfXposY – is the halflength in x at maximal y
halfYneg – is the halflength into y < 0
halfYpos – is the halflength into y > 0
-
inline DiamondBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array.
- Parameters
values – The parameter values
-
~DiamondBounds() override = default
-
virtual const RectangleBounds &boundingBox() const final
Bounding box parameters.
- Returns
rectangle bounds for a bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostream in which it is dumped
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const final
Return the vertices.
Note
the number of segements is ignored for this representation
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
enum BoundValues
-
struct DigitizationCell
- #include <Acts/Digitization/DigitizationCell.hpp>
pair of ints for definition of a cell
Public Functions
-
inline DigitizationCell(size_t ch0, size_t ch1, float d = 0.)
-
DigitizationCell(const DigitizationCell &dc) = default
-
inline void addCell(const DigitizationCell &dc, bool analogueReadout)
To merge cells in case they are at the same position.
Note
this function is needed because possible derived classes may calculate the energy deposit differently. Furthermore this allows to apply an energy cut, because the energy deposit can also be stored for digital readout.
- Parameters
dc – the cell to be added to the current cell
analogueReadout – flag indicating if we have analgue readout
-
inline double depositedEnergy() const
the deposited energy
Note
this function is needed because possible derived classes may calculate the energy deposit differently. Furthermore this allows to apply an energy cut, because the energy deposit can also be stored for digital readout.
Public Members
-
size_t channel0 = 0
-
size_t channel1 = 1
-
float data = 0.
-
inline DigitizationCell(size_t ch0, size_t ch1, float d = 0.)
-
class DigitizationModule
- #include <Acts/Digitization/DigitizationModule.hpp>
Class that holds the surfaces for a planar digitization detector module.
It needs a descriptor to design different pixel/strixels/strip setups (with a segmentation class) in order to define the readout segmentation
The digitizaiton is done in the local frame of the surface.
The lorentz angle is assumed to be only in x-direction and constant for the module, it is measured from the local z-direction towards the local x-direction.
The readout direction defines the charge drift either: a) towards the surface at -halfThickness if readout is defined at -1 b) towards the surface at +halfThickness if readout is defined at +1
Conventions:
3D positions are within the 3D frame of the module
2D positions are corrected to parameter surface at the center of the module (and not the readout surface)
The lorenzShift is the correction from the readout surface to the parameter surface
Public Functions
Constructor from a Segmentation descriptor.
- Parameters
moduleSegmentation – is the segmentation descriptions
halfThickness – is the half thickness of the module
readoutDirection – is the readout drift direction
lorentzAngle – is the lorentz drift angle
energyThreshold – Optional energy threshold for digitization
analogue – Run analogue digitization (defaults to false)
-
virtual ~DigitizationModule() = default
Virtual Destructor.
-
inline bool analogue() const
Indicates if the readout of the module is analogue, default is digital.
-
inline const SurfacePtrVector &boundarySurfaces() const
Return the bounding surfaces inlcuding top and bottom.
-
const DigitizationCell cell(const Vector2 &position) const
Get the digitization cell from a position.
- Parameters
position – The position to query
- Returns
-
inline DigitizationStep digitizationStep(const Vector3 &start, const Vector3 &end) const
Fill the associated digitization cell from this start and end position, correct for lorentz effect if needed.
- Parameters
start – is the start position of the step
end – is the end position of the step
- Returns
the digitization step
-
inline double energyThreshold() const
Return the energy threshold per cell of the module.
-
inline double halfThickness() const
Return the module thickness.
-
inline double lorentzAngle() const
Return the lorentz Angle.
-
inline int readoutDirection() const
Return the readout direction.
-
inline const Segmentation &segmentation() const
return the segmenation
-
const SurfacePtrVector segmentationSurfaces(const DigitizationCell &entryCids, const DigitizationCell &exitCids) const
Return the internal test segmentation surfaces to test between entry and exit given by their cell id’s - the boundaries are not given.
- Parameters
entryCids – are the entry digitisation cell ids
exitCids – are the exit digitisation cell ids
- Returns
object is a vector of shared surfaces
-
inline const SurfacePtrVector &segmentationSurfacesX() const
Return all surfaces in X - excluding the boundaries.
-
inline const SurfacePtrVector &segmentationSurfacesY() const
Return all surfaces in Y - excluding the boundaries.
-
SurfacePtrVector stepSurfaces(const Vector3 &start, const Vector3 &end) const
Return the test surfaces between these points.
- Parameters
start – is the start position of the step
end – is the end position of the step
- Returns
stepSurfaces are the surfaces to test
-
class DigitizationSourceLink : public Acts::SourceLink
- #include <Acts/Digitization/DigitizationSourceLink.hpp>
Source link to connect digitization clusters back to truth information.
Public Functions
-
inline DigitizationSourceLink(GeometryIdentifier gid, std::vector<std::size_t> indices = {})
Constructor from geometry identifier and truth indices.
- Parameters
gid – is the geometry identifier
indices – are the truth indices
-
inline DigitizationSourceLink()
Construct and invalid source link.
Must be default constructible to satisfy SourceLinkConcept.
-
DigitizationSourceLink(const DigitizationSourceLink&) = default
-
DigitizationSourceLink(DigitizationSourceLink&&) = default
-
inline const std::vector<std::size_t> &indices() const
Access all associated truth indices.
-
DigitizationSourceLink &operator=(const DigitizationSourceLink&) = default
-
DigitizationSourceLink &operator=(DigitizationSourceLink&&) = default
-
inline DigitizationSourceLink(GeometryIdentifier gid, std::vector<std::size_t> indices = {})
-
struct DigitizationStep
- #include <Acts/Digitization/DigitizationCell.hpp>
DigitizationStep for further handling.
Public Functions
-
inline DigitizationStep()
this is the cell position
Standard constructor
-
inline DigitizationStep(double sl, double dl, const DigitizationCell &dc, const Vector3 &entryP, const Vector3 &exitP, const Vector2 &projectedPosition, const Vector2 &cellPosition)
Constructor with arguments.
- Parameters
sl – step length of this step
dl – drift length of this step
dc – is the digitization zell (with indices)
entryP – is the entry position into the cell
exitP – is the exit position from the cell
projectedPosition – is the position on the readout surface
cellPosition – is the nominal position of the cell
Public Members
-
double driftLength = {0.}
this is the path length within the cell
-
DigitizationCell stepCell
this is the path length of the setp center to the readout surface
-
Vector2 stepCellCenter
this is the projected position at the readout surface
-
Vector3 stepEntry
this is the cell identifier of the segment
-
Vector3 stepExit
this is the Entry point into the segment
-
double stepLength = {0.}
-
Vector2 stepReadoutProjected
this is the Exit point from the segment
-
inline DigitizationStep()
- #include <Acts/Propagator/DirectNavigator.hpp>
DirectNavigator class.
This is a fully guided navigator that progresses through a pre-given sequence of surfaces.
This can either be used as a validation tool, for truth tracking, or track refitting
Public Types
The sequentially crossed surfaces.
Public Functions
Defaulted Constructed.
Navigator status call.
- Template Parameters
propagator_state_t – is the type of Propagatgor state
stepper_t – is the used type of the Stepper by the Propagator
- Parameters
state – [inout] is the mutable propagator state object
stepper – [in] Stepper in use
Navigator target call.
- Template Parameters
propagator_state_t – is the type of Propagatgor state
stepper_t – is the used type of the Stepper by the Propagator
- Parameters
state – [inout] is the mutable propagator state object
stepper – [in] Stepper in use
Public Members
The tolerance used to define “surface reached”.
- #include <Acts/Propagator/DirectNavigator.hpp>
Nested Actor struct, called Initializer.
This is needed for the initialization of the surface sequence
Public Types
Public Functions
Defaulting the constructor.
Actor operator call.
- Template Parameters
statet – Type of the full propagator state
stepper_t – Type of the stepper
- Parameters
state – the entire propagator state
r – the result of this Actor
Actor operator call - resultless, unused.
Public Members
The Surface sequence.
- #include <Acts/Propagator/DirectNavigator.hpp>
Actor result / state.
Public Members
- #include <Acts/Propagator/DirectNavigator.hpp>
Nested State struct.
It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information
Public Functions
Reset state.
- Parameters
ssurface – is the new starting surface
tsurface – is the target surface
Public Members
Navigation state - external interface: the current surface.
Navigation state: the current volume.
Navigation state - external interface: a break has been detected.
Iterator the next surface.
Externally provided surfaces - expected to be ordered along the path.
Navigation state - starting layer.
Navigation state - external interface: the start surface.
Navigation state: the start volume.
Navigation state - target layer.
Navigation state - external interface: target is reached.
Navigation state - external interface: the target surface.
Navigation state: the target volume.
-
class DiscBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/DiscBounds.hpp>
common base class for all bounds that are in a r/phi frame
simply introduced to avoid wrong bound assigments to surfaces
Subclassed by Acts::AnnulusBounds, Acts::DiscTrapezoidBounds, Acts::RadialBounds
Public Functions
-
virtual double binningValuePhi() const = 0
Returns a refererance phi for binning.
-
virtual double binningValueR() const = 0
Returns a reference radius for binning.
-
virtual bool coversFullAzimuth() const = 0
Returns true for full phi coverage.
-
virtual bool insideRadialBounds(double R, double tolerance = 0.) const = 0
Checks if it’s inside the radius.
-
virtual double rMax() const = 0
Return method for outer Radius.
-
virtual double rMin() const = 0
Return method for inner Radius.
-
virtual std::vector<Vector2> vertices(unsigned int lseg) const = 0
Return the vertices.
Note
that the extremas are given, which may slightly alter the number of segments returned
- Parameters
lseg – the number of segments used to approximate and eventually curved line, the number referrs to full 2*PI
- Returns
vector for vertices in 2D
-
class DiscLayer : public virtual Acts::DiscSurface, public Acts::Layer
- #include <Acts/Geometry/DiscLayer.hpp>
Class to describe a disc-like detector layer for tracking, it inhertis from both, Layer base class and DiscSurface class.
Public Functions
-
DiscLayer() = delete
-
DiscLayer(const DiscLayer &cla) = delete
-
~DiscLayer() override = default
-
virtual const DiscSurface &surfaceRepresentation() const override
Transforms the layer into a Surface representation for extrapolation.
- Returns
This method returns a surface reference
-
virtual DiscSurface &surfaceRepresentation() override
Public Static Functions
Factory constructor with DiscSurface components.
- Parameters
transform – is the transform to place the layer in the 3D frame
dbounds – are the disc bounds that describe the layer dimensions
surfaceArray – is the array of sensitive surfaces
thickness – is the layer thickness (along the normal vector)
ad – is the approach descriptor that provides the approach surface
laytyp – is the layer type
- Returns
a sharted pointer to the new layer
-
DiscLayer() = delete
-
class DiscSurface : public Acts::Surface
- #include <Acts/Surfaces/DiscSurface.hpp>
Class for a DiscSurface in the, it inherits from Surface.
The DiscSurface has a polar local coordinate system, with (r,phi) describing the coordinates.
The surface transform positions the disc such, that the origin is at r=0, independent of the provided DiscBounds. The z-axis The normal vector of the Disc, being perpendicular to the radial direction.
The disc surface The only surface type for which the covariance matrix is NOT given in the reference frame. A conversion from polar to cartesian coordinates needs to happen to transfer the local coordinates onto the cartesian reference frame coordinates.
Subclassed by Acts::DiscLayer
Public Functions
-
DiscSurface() = delete
-
~DiscSurface() override = default
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const final
The binning position The position calcualted for a certain binning type.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – The binning type to be used
- Returns
position that can beused for this binning
-
virtual double binningPositionValue(const GeometryContext &gctx, BinningValue bValue) const final
Implement the binningValue.
Note
This calls the parent method except for binR
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the dobule in which you want to bin
- Returns
float to be used for the binning schema
-
virtual const SurfaceBounds &bounds() const final
This method returns the bounds by reference.
-
virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const BoundVector &boundParams) const final
Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.
- Parameters
gctx – The current geometry context object, e.g. alignment
boundParams – is the bound parameters vector
- Returns
Jacobian from local to global
-
virtual FreeToBoundMatrix freeToBoundJacobian(const GeometryContext &gctx, const FreeVector ¶meters) const final
Calculate the jacobian from global to local which the surface knows best, hence the calculation is done here.
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Jacobian from global to local
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const final
Global to local transformation.
Note
the momentum is ignored for Disc surfaces in this calculateion
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
momentum – global 3D momentum representation (optionally ignored)
tolerance – optional tolerance within which a point is considered valid on surface
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
Vector2 globalToLocalCartesian(const GeometryContext &gctx, const Vector3 &position, double tol = 0.) const
Special method for DiscSurface : global<->local from cartesian coordinates.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is a global cartesian 3D position
tol – The absoltue tolerance parameter
- Returns
value is a local polar
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck = false) const final
Straight line intersection schema.
mathematical motivation:
the equation of the plane is given by: \( \vec n \cdot \vec x = \vec n \cdot \vec p,\) where \( \vec n = (n_{x}, n_{y}, n_{z})\) denotes the normal vector of the plane, \( \vec p = (p_{x}, p_{y}, p_{z})\) one specific point on the plane and \( \vec x = (x,y,z) \)
all possible points on the plane.
Given a line with:
\( \vec l(u) = \vec l_{1} + u \cdot \vec v \),
the solution for
\( u \) can be written: \( u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}\) If the denominator is 0 then the line lies:either in the plane
perpendicular to the normal of the plane
Note
expected to be normalized (no checking)
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The global position as a starting point
direction – The global direction at the starting point
bcheck – The boundary check prescription
- Returns
The SurfaceIntersection object
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
Vector3 localCartesianToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const
Special method for DiscSurface : local<->global transformation when provided cartesian coordinates.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is local 2D position in cartesian coordinates
- Returns
value is a global cartesian 3D position
-
Vector2 localCartesianToPolar(const Vector2 &lcart) const
Special method for Disc surface : local<->local transformations polar <-> cartesian.
- Parameters
lcart – is local 2D position in cartesian coordinates
- Returns
value is a local position in polar coordinates
-
Vector2 localPolarToCartesian(const Vector2 &lpolar) const
Special method for DiscSurface : local<->local transformations polar <-> cartesian.
- Parameters
lpolar – is a local position in polar coordinates
- Returns
values is local 2D position in cartesian coordinates
-
Vector2 localPolarToLocalCartesian(const Vector2 &locpol) const
Special method for DiscSurface : local<->local transformations polar <-> cartesian.
- Parameters
locpol – is a local position in polar coordinates
- Returns
values is local 2D position in cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const final
Local to global transformation For planar surfaces the momentum is ignroed in the local to global transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – local 2D position in specialized surface frame
momentum – global 3D momentum representation (optionally ignored)
- Returns
global position by value
-
virtual std::string name() const override
Return properly formatted class name for screen output.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final
Normal vector return.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – The local position is ignored
- Returns
a Vector3 by value
-
DiscSurface &operator=(const DiscSurface &other)
Assignement operator.
- Parameters
other – The source sourface for the assignment
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final
Path correction due to incident of the track.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The global position as a starting point
direction – The global momentum at the starting point
- Returns
The correction factor due to incident
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const override
Return a Polyhedron for the surfaces.
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, it represents the full 2*M_PI coverange, if lseg is set to 1 only the extrema are given
- Returns
A list of vertices and a face/facett description of it
-
virtual SurfaceType type() const override
Return the surface type.
-
DiscSurface() = delete
-
class DiscTrapezoidBounds : public Acts::DiscBounds
- #include <Acts/Surfaces/DiscTrapezoidBounds.hpp>
Class to describe the bounds for a planar DiscSurface.
By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.
Public Types
-
enum BoundValues
Values:
-
enumerator eHalfLengthXminR
-
enumerator eHalfLengthXmaxR
-
enumerator eMinR
-
enumerator eMaxR
-
enumerator eAveragePhi
-
enumerator eStereo
-
enumerator eSize
-
enumerator eHalfLengthXminR
Public Functions
-
DiscTrapezoidBounds() = delete
-
DiscTrapezoidBounds(double halfXminR, double halfXmaxR, double minR, double maxR, double avgPhi = M_PI_2, double stereo = 0.) noexcept(false)
Constructor for a symmetric Trapezoid giving min X length, max X length, Rmin and R max.
- Parameters
halfXminR – half length in X at min radius
halfXmaxR – half length in X at maximum radius
minR – inner radius
maxR – outer radius
avgPhi – average phi value
stereo – optional stero angle applied
-
inline DiscTrapezoidBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array.
- Parameters
values – The parameter values
-
~DiscTrapezoidBounds() override = default
-
inline virtual double binningValuePhi() const final
Return a reference phi for binning.
-
inline virtual double binningValueR() const final
Return a reference radius for binning.
-
inline virtual bool coversFullAzimuth() const final
Returns true for full phi coverage - obviously false here.
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
inline double halfLengthY() const
This method returns the half length in Y (this is Rmax -Rmin)
-
inline double halfPhiSector() const
This method returns the halfPhiSector which is covered by the disc.
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck = true) const final
This method cheks if the radius given in the LocalPosition is inside [rMin,rMax] if only tol0 is given and additional in the phi sector is tol1 is given.
- Parameters
lposition – is the local position to be checked (in polar coordinates)
bcheck – is the boundary check directive
-
inline virtual bool insideRadialBounds(double R, double tolerance = 0.) const final
Checks if this is inside the radial coverage given the a tolerance.
-
inline double rCenter() const
This method returns the center radius.
-
inline virtual double rMax() const final
This method returns outer radius.
-
inline virtual double rMin() const final
This method returns inner radius.
-
inline double stereo() const
This method returns the stereo angle.
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
-
virtual SurfaceBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
virtual std::vector<Vector2> vertices(unsigned int lseg) const final
This method returns the xy coordinates of the four corners of the bounds in module coorindates (in xy)
Note
that the number of segments are ignored for this surface
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
enum BoundValues
-
template<class T>
class DistanceSorterT - #include <Acts/Geometry/GeometryObjectSorter.hpp>
This will check on absolute distance.
Public Functions
-
inline DistanceSorterT(BinningValue bValue, Vector3 reference)
Constructor from a binning value.
- Parameters
bValue – is the value in which the binning is done
reference – is the reference point
-
inline DistanceSorterT(BinningValue bValue, Vector3 reference)
-
template<typename input_track_t = BoundTrackParameters, typename linearizer_t = DummyTrackLinearizer>
class DummyVertexFitter - #include <Acts/Vertexing/DummyVertexFitter.hpp>
Dummy vertex fitter class, only to be used for ensuring interfaces where a vertex fitter type is required but no fitter is actually needed.
Public Types
-
using InputTrack_t = input_track_t
-
using Linearizer_t = linearizer_t
-
using Propagator_t = void
Public Functions
-
DummyVertexFitter() = delete
-
Result<Vertex<input_track_t>> fit(const std::vector<input_track_t>&, const linearizer_t&, const VertexingOptions<input_track_t>&) const
Dummy fit method.
-
using InputTrack_t = input_track_t
-
template<typename extensionlist_t = StepperExtensionList<DefaultExtension>, typename auctioneer_t = detail::VoidAuctioneer>
class EigenStepper - #include <Acts/Propagator/EigenStepper.hpp>
Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE:
r = (x,y,z) … global position T = (Ax,Ay,Az) … momentum direction (normalized)
dr/ds = T dT/ds = q/p * (T x B)
with s being the arc length of the track, q the charge of the particle, p the momentum magnitude and B the magnetic field
Subclassed by Acts::MultiEigenStepperLoop< extensionlist_t, component_reducer_t, auctioneer_t >
Public Types
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
using Covariance = BoundSymMatrix
-
using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>
-
using Jacobian = BoundMatrix
Jacobian, Covariance and State defintions.
Public Functions
Constructor requires knowledge of the detector’s magnetic field.
-
Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Create and return the bound state at the current position.
This transports (if necessary) the covariance to the surface and creates a bound state. It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator
- Parameters
state – [in] State that will be presented as
BoundState
surface – [in] The surface to which we bind the state
transportCov – [in] Flag steering covariance transport
freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound
- Returns
A bound state:
the parameters at the surface
the stepwise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline double charge(const State &state) const
Charge access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
CurvilinearState curvilinearState(State &state, bool transportCov = true) const
Create and return a curvilinear state at the current position.
This transports (if necessary) the covariance to the current position and creates a curvilinear state.
- Parameters
state – [in] State that will be presented as
CurvilinearState
transportCov – [in] Flag steering covariance transport
- Returns
A curvilinear state:
the curvilinear parameters at given position
the stepweise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline Vector3 direction(const State &state) const
Momentum direction accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline Result<Vector3> getField(State &state, const Vector3 &pos) const
Get the field for the stepping, it checks first if the access is still within the Cell, and updates the cell if necessary.
- Parameters
state – [inout] is the propagation state associated with the track the magnetic field cell is used (and potentially updated)
pos – [in] is the field position
-
inline double getStepSize(const State &state, ConstrainedStep::Type stype) const
Get the step size.
- Parameters
state – [in] The stepping state (thread-local cache)
stype – [in] The step size type to be returned
-
inline double momentum(const State &state) const
Absolute momentum accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline std::string outputStepSize(const State &state) const
Output the Step Size - single component.
- Parameters
state – [in,out] The stepping state (thread-local cache)
-
inline double overstepLimit(const State&) const
Overstep limit.
-
inline Vector3 position(const State &state) const
Global particle position accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline void releaseStepSize(State &state) const
Release the Step size.
- Parameters
state – [in,out] The stepping state (thread-local cache)
Resets the state.
- Parameters
state – [inout] State of the stepper
boundParams – [in] Parameters in bound parametrisation
cov – [in] Covariance matrix
surface – [in] The reference surface of the bound parameters
navDir – [in] Navigation direction
stepSize – [in] Step size
-
void setIdentityJacobian(State &state) const
Method that reset the Jacobian to the Identity for when no bound state are available.
- Parameters
state – [inout] State of the stepper
-
inline void setStepSize(State &state, double stepSize, ConstrainedStep::Type stype = ConstrainedStep::actor, bool release = true) const
Set Step size - explicitely with a double.
- Parameters
state – [in,out] The stepping state (thread-local cache)
stepSize – [in] The step size value
stype – [in] The step size type to be set
release – [in] Do we release the step size?
-
template<typename propagator_state_t>
Result<double> step(propagator_state_t &state) const Perform a Runge-Kutta track parameter propagation step.
Note
The state contains the desired step size. It can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.
- Parameters
state – [inout] is the propagation
-
inline double time(const State &state) const
Time access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
Note
no check is done if the position is actually on the surface
- Template Parameters
surface_t – the Surface type
- Parameters
state – [inout] State of the stepper
surface – [in] is the surface to which the covariance is forwarded to
freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound
-
void transportCovarianceToCurvilinear(State &state) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
- Parameters
state – [inout] State of the stepper
-
void update(State &state, const FreeVector &freeParams, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const
Method to update a stepper state to the some parameters.
- Parameters
state – [inout] State object that will be updated
freeParams – [in] Free parameters that will be written into
state
boundParams – [in] Corresponding bound parameters used to update jacToGlobal in
state
covariance – [in] The covariance that will be written into
state
surface – [in] The surface used to update the jacToGlobal
-
void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double up, double time) const
Method to update momentum, direction and p.
- Parameters
state – [inout] State object that will be updated
uposition – [in] the updated position
udirection – [in] the updated direction
up – [in] the updated momentum value
time – [in] the updated time value
-
template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, bool release = true) const Update step size.
This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.
- Parameters
state – [in,out] The stepping state (thread-local cache)
oIntersection – [in] The ObjectIntersection to layer, boundary, etc
release – [in] boolean to trigger step size release
-
inline Intersection3D::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck, LoggerWrapper logger = getDummyLogger()) const
Update surface status.
It checks the status to the reference surface & updates the step size accordingly
- Parameters
state – [inout] The stepping state (thread-local cache)
surface – [in] The surface provided
bcheck – [in] The boundary check for this status update
logger – [in] A
LoggerWrapper
instance
-
struct State
- #include <Acts/Propagator/EigenStepper.hpp>
State for track parameter propagation.
It contains the stepping information and is provided thread local by the propagator
Public Functions
-
State() = delete
Constructor from the initial bound track parameters.
Note
the covariance matrix is copied when needed
- Template Parameters
charge_t – Type of the bound parameter charge
- Parameters
gctx – [in] is the context object for the geometry
fieldCacheIn – [in] is the cache object for the magnetic field
par – [in] The track parameters at start
ndir – [in] The navigation direction w.r.t momentum
ssize – [in] is the maximum step size
stolerance – [in] is the stepping tolerance
Public Members
-
auctioneer_t auctioneer
Auctioneer for choosing the extension.
-
Vector3 B_first
Magnetic field evaulations.
-
Vector3 B_last
-
Vector3 B_middle
-
Covariance cov = Covariance::Zero()
-
bool covTransport = false
Covariance matrix (and indicator) associated with the initial error on track parameters.
-
FreeVector derivative = FreeVector::Zero()
The propagation derivative.
-
extensionlist_t extension
List of algorithmic extensions.
-
MagneticFieldProvider::Cache fieldCache
This caches the current magnetic field cell and stays (and interpolates) within it as long as this is valid.
See step() code for details.
-
std::reference_wrapper<const GeometryContext> geoContext
The geometry context.
-
BoundToFreeMatrix jacToGlobal = BoundToFreeMatrix::Zero()
Jacobian from local to the global frame.
-
FreeMatrix jacTransport = FreeMatrix::Identity()
Pure transport jacobian part from runge kutta integration.
-
Vector3 k1
k_i of the RKN4 algorithm
-
Vector3 k2
-
Vector3 k3
-
Vector3 k4
-
std::array<double, 4> kQoP
k_i elements of the momenta
Navigation direction, this is needed for searching.
-
FreeVector pars = FreeVector::Zero()
Internal free vector parameters.
-
double pathAccumulated = 0.
Accummulated path length state.
-
double previousStepSize = 0.
Last performed step (for overstep limit calculation)
-
double q = 1.
The charge as the free vector can be 1/p or q/p.
-
struct Acts::EigenStepper::State::[anonymous] stepData
Storage of magnetic field and the sub steps during a RKN4 step.
-
ConstrainedStep stepSize
Adaptive step size of the runge-kutta integration.
-
double tolerance = s_onSurfaceTolerance
The tolerance for the stepping.
-
State() = delete
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
class ElementFraction
- #include <Acts/Material/MaterialComposition.hpp>
Memory-efficient storage of the relative fraction of an element.
This can be used to define materials that are compounds of multiple elements with varying fractions. The element is identified by its atomic number stored as a single byte (allows up to 256 elements; more than we need). Its fraction is also stored as a single byte with values between 0 and
This gives an accuracy of 1/256 ~ 0.5 %.
The element fraction allows you to store element composition in merged materials with a large number of bins. Depending on the detector and the description granularity this can be a lot of information and thus requires the reduced memory footprint. This is really only needed for nuclear interaction in the fast simulation where the reduced fractional accuracy is not a problem. The fractional accuracy should be much better than the parametrization uncertainty for hadronic interactions.
Public Functions
-
inline constexpr ElementFraction(unsigned int e, float f)
Construct from atomic number and relative fraction.
- Parameters
e – is the atomic number of the element
f – is the relative fraction and must be a value in [0,1]
-
inline explicit constexpr ElementFraction(unsigned int e, unsigned int w)
Construct from atomic number and integer weight.
- Parameters
e – is the atomic number of the element
w – is the integer weight and must be a value in [0,256)
-
ElementFraction() = delete
Must always be created with valid data.
-
ElementFraction(ElementFraction&&) = default
-
ElementFraction(const ElementFraction&) = default
-
~ElementFraction() = default
-
inline constexpr uint8_t element() const
The element atomic number.
-
inline constexpr float fraction() const
The relative fraction of this element.
-
ElementFraction &operator=(ElementFraction&&) = default
-
ElementFraction &operator=(const ElementFraction&) = default
-
class EllipseBounds : public Acts::PlanarBounds
- #include <Acts/Surfaces/EllipseBounds.hpp>
Class to describe the bounds for a planar ellispoid surface.
By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.
Public Types
-
enum BoundValues
Values:
-
enumerator eInnerRx
-
enumerator eInnerRy
-
enumerator eOuterRx
-
enumerator eOuterRy
-
enumerator eHalfPhiSector
-
enumerator eAveragePhi
-
enumerator eSize
-
enumerator eInnerRx
Public Functions
-
EllipseBounds() = delete
-
inline EllipseBounds(double innerRx, double innerRy, double outerRx, double outerRy, double halfPhi = M_PI, double averagePhi = 0.) noexcept(false)
Constructor for full of an ellipsoid ring.
- Parameters
innerRx – The inner ellipse radius in x
innerRy – The inner ellipse radius in y
outerRx – The outer ellipse radius in x
outerRy – The outer ellipse radius in y
halfPhi – spanning phi sector (is set to pi as default)
averagePhi – average phi (is set to 0. as default)
-
inline EllipseBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array.
- Parameters
values – The parameter values
-
~EllipseBounds() override = default
-
virtual const RectangleBounds &boundingBox() const final
Bounding box parameters.
- Returns
rectangle bounds for a bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
This method checks if the point given in the local coordinates is between two ellipsoids if only tol0 is given and additional in the phi sector is tol1 is given.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
virtual std::vector<Vector2> vertices(unsigned int lseg) const final
Return the vertices.
Note
the number of segements to may be altered by also providing the extremas in all direction
- Parameters
lseg – the number of segments used to approximate and eventually curved line, here it refers to the full 2PI Ellipse
- Returns
vector for vertices in 2D
-
enum BoundValues
-
struct EndOfWorldReached
- #include <Acts/Propagator/StandardAborters.hpp>
This is the condition that the end of World has been reached it then triggers an propagation abort.
Public Functions
-
EndOfWorldReached() = default
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t&) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
- Parameters
state – [inout] The propagation state object
-
EndOfWorldReached() = default
-
struct EventDataView3D
- #include <Acts/Visualization/EventDataView3D.hpp>
Public Static Functions
-
static inline std::vector<Vector3> createEllipse(double lambda0, double lambda1, double theta, size_t lseg, double offset, const Vector2 &lposition = Vector2(0., 0.), const Transform3 &transform = Transform3::Identity())
Helper mehod to draw the ellipse points.
- Parameters
lambda0 – The Eigenvalue in 0
lambda1 – The Eigenvalue in 1
theta – The angle between the x/y frame and EV frame
lseg – The number of segments
offset – The out of plane offset for visibility
lposition – The local anker point of the ellipse
transform – The transform to global
-
static inline std::array<double, 3> decomposeCovariance(const ActsSymMatrix<2> &covariance)
Helper to find the egen values and corr angle.
- Parameters
covariance – The covariance matrix
-
template<typename parameters_t>
static inline void drawBoundTrackParameters(IVisualization3D &helper, const parameters_t ¶meters, const GeometryContext &gctx = GeometryContext(), double momentumScale = 1., double locErrorScale = 1., double angularErrorScale = 1., const ViewConfig &parConfig = s_viewParameter, const ViewConfig &covConfig = s_viewParameter, const ViewConfig &surfConfig = s_viewSensitive) Helper method to draw bound parameters object.
- Parameters
helper – [in, out] The visualization helper
parameters – The bound parameters to be drawn
gctx – The geometry context for which it is drawn
momentumScale – The scale of the momentum
locErrorScale – The scale of the local error
angularErrorScale – The sclae of the angular error
parConfig – The visualization options for the parameter
covConfig – The visualization option for the covariance
surfConfig – The visualization option for the surface
-
static void drawCovarianceAngular(IVisualization3D &helper, const Vector3 &position, const Vector3 &direction, const ActsSymMatrix<2> &covariance, double directionScale = 1, double angularErrorScale = 1, const ViewConfig &viewConfig = s_viewParameter)
Helper method to draw error cone of a direction.
- Parameters
helper – [in, out] The visualization helper
position – Where the cone originates from
direction – The direction parameters
covariance – The 2x2 covariance matrix for phi/theta
directionScale – The direction arror length
angularErrorScale – The local Error scale
viewConfig – The visualization parameters
-
static void drawCovarianceCartesian(IVisualization3D &helper, const Vector2 &lposition, const SymMatrix2 &covariance, const Transform3 &transform, double locErrorScale = 1, const ViewConfig &viewConfig = s_viewParameter)
Helper method to draw error ellipse.
- Parameters
helper – [in, out] The visualization helper
lposition – The local position
covariance – The covariance matrix
transform – The reference Frame transform
locErrorScale – The local Error scale
viewConfig – The visualization parameters
-
template<typename D>
static inline void drawMultiTrajectory(IVisualization3D &helper, const Acts::MultiTrajectory<D> &multiTraj, const size_t &entryIndex, const GeometryContext &gctx = GeometryContext(), double momentumScale = 1., double locErrorScale = 1., double angularErrorScale = 1., const ViewConfig &surfaceConfig = s_viewSensitive, const ViewConfig &measurementConfig = s_viewMeasurement, const ViewConfig &predictedConfig = s_viewPredicted, const ViewConfig &filteredConfig = s_viewFiltered, const ViewConfig &smoothedConfig = s_viewSmoothed) Helper method to draw one trajectory stored in a MultiTrajectory object.
- Parameters
helper – [in, out] The visualization helper
multiTraj – The MultiTrajectory storing the trajectory to be drawn
entryIndex – The trajectory entry index
gctx – The geometry context for which it is drawn
momentumScale – The scale of the momentum
locErrorScale – The scale of the local error
angularErrorScale – The sclae of the angular error
surfaceConfig – The visualization options for the surface
measurementConfig – The visualization options for the measurement
predictedConfig – The visualization options for the predicted measurement
filteredConfig – The visualization options for the filtered parameters
smoothedConfig – The visualization options for the smoothed parameters
-
static inline std::vector<Vector3> createEllipse(double lambda0, double lambda1, double theta, size_t lseg, double offset, const Vector2 &lposition = Vector2(0., 0.), const Transform3 &transform = Transform3::Identity())
-
class Extent
- #include <Acts/Geometry/Extent.hpp>
A class representing the geometric extent of an object in its possbile dimensions, these can be all dimensions that are described as BinningValues.
The extent object can have an optional envelope in all of those values
Note
that the consistency of the different envelopes is not checked
Public Functions
-
Extent(const ExtentEnvelope &envelope = zeroEnvelopes)
Constructor with (optional)
- Parameters
envelope –
-
bool constrains(BinningValue bValue = binValues) const
Constraints check.
- Parameters
bValue – is the binning value, if all the check on all is done
-
bool contains(const Extent &rhs, BinningValue bValue = binValues) const
Contains check.
- Parameters
rhs – the extent that is check if it is contained
bValue – is the binning value, if set to binValues the check on all is done
- Returns
true if the rhs is contained
-
inline ExtentEnvelope &envelope()
Return the envelope - non-const access.
-
inline const ExtentEnvelope &envelope() const
Return the envelope - const access.
-
void extend(const Vector3 &vtx, const std::vector<BinningValue> &bValues = s_binningValues, bool applyEnv = true, bool fillHistograms = false)
Extend with a position vertex.
- Parameters
vtx – the vertex to be used for extending
bValues – the binning values
applyEnv – boolean to steer if envelope should be applied
fillHistograms – is a boolean flag to steer whether the values to fill this extent should be stored
-
template<typename vector_iterator_t>
inline void extend(const vector_iterator_t &start, const vector_iterator_t &end, const std::vector<BinningValue> &bValues = s_binningValues, bool applyEnv = true, bool fillHistograms = false) Extend with a set of vectors by iterators.
- Parameters
start – the start iterator of the loop
end – the end iterator of the loop
bValues – the binning values
applyEnv – boolean to steer if envelope should be applied
fillHistograms – is a boolean flag to steer whether the values to fill this extent should be stored
-
void extend(const Extent &rhs, const std::vector<BinningValue> &bValues = s_binningValues, bool applyEnv = true)
Extend with another geometric extent, usually pushes the current range to the boundaries of the rhs extent, unless the current extent is already bigger.
Note
the extent can also simply set an envelope which then is applied to the current one
Note
that the histogram values can not be filled in this call
- Parameters
rhs – is the other source Extent
bValues – the binning values
applyEnv – boolean to steer if envelope should be applied on the constraint values, if only an envelope is given but the value not constraint, then it is always applied
-
bool intersects(const Extent &rhs, BinningValue bValue = binValues) const
Intersection checks.
- Parameters
rhs – the extent that is check for intersection
bValue – is the binning value, if set to binValues the check on all is done
- Returns
true if the rhs intersects
-
inline ActsScalar max(BinningValue bValue) const
Access the maximum parameter.
- Parameters
bValue – the binning identification
-
inline ActsScalar medium(BinningValue bValue) const
Access the maximum parameter.
- Parameters
bValue – the binning identification
-
inline ActsScalar min(BinningValue bValue) const
Access the minimum parameter.
- Parameters
bValue – the binning identification
-
inline Range1D<ActsScalar> &range(BinningValue bValue)
Return the individual 1-dimensional range.
- Parameters
bValue – is the binning value to be returned
- Returns
a one dimensional arrange
-
inline const Range1D<ActsScalar> &range(BinningValue bValue) const
Return the individual 1-dimensional range.
- Parameters
bValue – is the binning value to be returned
- Returns
a one dimensional arrange
-
inline const RangeXD<binValues, ActsScalar> range() const
Return the N-dimension range.
-
template<unsigned int kSUBDIM>
inline RangeXD<kSUBDIM, ActsScalar> range(const std::array<BinningValue, kSUBDIM> &binValues) const Return an D-dimensional sub range according to the the given.
- Parameters
binValues –
-
void set(BinningValue bValue, ActsScalar min, ActsScalar max)
Set a range for a dedicated binning value.
- Parameters
bValue – the binning identification
min – the minimum parameter
max – the maximum parameter
-
void setEnvelope(const ExtentEnvelope &envelope = zeroEnvelopes)
(re-)Set the envelope
- Parameters
envelope – new envelope to be set
-
std::ostream &toStream(std::ostream &sl) const
Convert to output stream for screen output.
- Parameters
sl – [in,out] The output stream
-
inline const std::array<std::vector<ActsScalar>, binValues> &valueHistograms() const
Return the histogram store.
The histogram stroe can be used for automated binning detection
-
Extent(const ExtentEnvelope &envelope = zeroEnvelopes)
-
template<typename Derived, typename ...States>
class FiniteStateMachine - #include <Acts/Utilities/FiniteStateMachine.hpp>
Implementation of a finite state machine engine.
Allows setting up a system of states and transitions between them. States are definedd as empty structs (footprint: 1 byte). Tranitions call functions using overload resolution. This works by subclassing this class, providing the deriving type as the first template argument (CRTP) and providing methods like
event_return on_event(const S&, const E&);
The arguments are the state
S
and the triggered eventE
. Their values can be discarded (you can attach values to events of course, if you like) The return type of these functions is effectivelystd::optional<State>
, so you can either returnstd::nullopt
to remain in the same state, or an instance of another state. That state will then become active.You can also define a method template, which will serve as a catch-all handler (due to the fact that it will match any state/event combination):
template <typename State, typename Event> event_return on_event(const State&, const Event&) const { return Terminated{}; }
If for a given state and event no suitable overload of
on_event
(and you also haven’t defined a catch-all as described above), a transition toTerminated
will be triggered. This is essentially equivalent to the method template above.If this triggers, it will switch to the
Terminated
state (which is always included in the FSM).Additionally, the FSM will attempt to call functions like
when entering/exiting a state. This can be used to perform actions regardless of the source or destination state in a transition to a given state. This is also fired in case a transition tovoid on_enter(const State&); void on_exit(const State&);
Terminated
occurs.The base class also calls
during event processing, and allow for things like event and transition logging.void on_process(const Event&); void on_process(const State&, const Event&); void on_process(const State1& const Event&, const State2&);
The
on_event
,on_enter
,on_exit
andon_process
methods need to be implemented exhaustively, i.e. for all state/event combinations. This might require you to add catch-all no-op functions likeand so on.template <typename...Args> event_return on_event(Args&&...args) {} // noop
The public interface for the user of the FSM are the
template <typename... Args> void setState(StateVariant state, Args&&... args); template <typename Event, typename... Args> void dispatch(Event&& event, Args&&... args) {
setState
triggers a transition to a given state,dispatch
triggers processing on an event from the given state. Both will call the appropriateon_exit
andon_enter
overloads. Both also accept an arbitrary number of additional arguments that are passed to theon_event
,on_exit
andon_enter
overloads.- Template Parameters
Derived – Class deriving from the FSM
States – Argument pack with the state types that the FSM can be handled.
Public Types
-
using StateVariant = std::variant<Terminated, States...>
Variant type allowing tagged type erased storage of the current state of the FSM.
Public Functions
-
inline FiniteStateMachine()
Default constructor.
The default state is taken to be the first in the
States
template arguments
-
inline FiniteStateMachine(StateVariant state)
Constructor from an explicit state.
The FSM is initialized to this state.
- Parameters
state – Initial state for the FSM.
-
template<typename Event, typename ...Args>
inline void dispatch(Event &&event, Args&&... args) Public interface to handle an event.
Will call the appropriate event handlers and perform any required transitions.
- Template Parameters
Event – Type of the event being triggered
Args – Additional arguments being passed to overload handlers.
- Parameters
event – Instance of the event being triggere
args – Additional arguments
-
inline const StateVariant &getState() const noexcept
Get the current state of the FSM (as a variant).
- Returns
StateVariant The current state of the FSM.
-
template<typename S>
inline bool is(const S &state) const noexcept Returns whether the FSM is in the specified state.
- Template Parameters
State – type to check against
- Parameters
state – State instance to check against
- Returns
Whether the FSM is in the given state.
-
template<typename S>
inline bool is() const noexcept Returns whether the FSM is in the specified state.
Alternative version directly taking only the template argument.
- Template Parameters
State – type to check against
- Returns
Whether the FSM is in the given state.
-
template<typename State, typename ...Args>
inline void setState(State state, Args&&... args) Sets the state to a given one.
Triggers
on_exit
andon_enter
for the given states.- Template Parameters
State – Type of the target state
Args – Additional arguments passed through callback overloads.
- Parameters
state – Instance of the target state
args – The additional arguments
-
inline bool terminated() const noexcept
Returns whether the FSM is in the terminated state.
- Returns
Whether the FSM is in the terminated state.
-
struct Terminated
- #include <Acts/Utilities/FiniteStateMachine.hpp>
Contractual termination state.
Is transitioned to if State+Event do not have a transition defined.
Public Static Attributes
-
static constexpr std::string_view name = "Terminated"
Name of this state (useful for logging)
-
static constexpr std::string_view name = "Terminated"
-
template<typename value_t, size_t DIM, size_t SIDES>
class Frustum - #include <Acts/Utilities/Frustum.hpp>
Class representing a frustum shape.
The frustum is defined using an origin, a direction and an opening angle. These parameters are then used to calculate a number of side planes, each having a position and a normal vector. The “near plane” is assumed to coincide with the origin point, and the normal with the “direction” of the frustum. No far plane is defined.
- Template Parameters
value_t – The floating point value to use
DIM – The number of dimensions of ambient space
SIDES – The number of sides (= side planes) the frustum has (exactly 2 in 2D, minimum 3 in 3D)
Public Types
-
using value_type = value_t
Re expose the value type.
Public Functions
-
template<size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
Frustum(const VertexType &origin, const VertexType &dir, value_type opening_angle) Constructor for the 2D case.
Note
The
opening_angle
is defined as the angle between opposing side planes. The opening angle needs to be < pi.- Parameters
origin – The origin of the frustum
dir – The direction of the frustum
opening_angle – The opening angle
-
template<size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
Frustum(const VertexType &origin, const VertexType &dir, value_type opening_angle) Constructor for the 3D case.
Note
The
opening_angle
is defined as the angle between opposing side planes. The opening angle needs to be < pi.- Parameters
origin – The origin of the frustum
dir – The direction of the frustum
opening_angle – The opening angle
-
inline const VertexType &dir() const
Getter for the direction of the frustum.
- Returns
The direction of the frustum
-
template<size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
void draw(IVisualization3D &helper, value_type far_distance = 10) const Draw a representation of this frustum using a visualization helper.
Note
This is only available for the 3D case.
- Parameters
helper – The visualization helper
far_distance – The distance to the virtual “far plane” at which point the side planes terminate visually.
-
inline const std::array<VertexType, SIDES + 1> &normals() const
Getter for the normal vectors of the planes defining this frustum.
Note
The size of the array that is returned is fixed to
number of sides + 1
- Returns
Array containing the normal vectors for all planes.
-
inline const VertexType &origin() const
Getter for the oriogin of the frustum.
- Returns
The origin of the frustum
-
template<size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
std::ostream &svg(std::ostream &os, value_type w, value_type h, value_type far_distance = 1, value_type unit = 20.) const Draw a representation of this frustum as an SVG string to an outstream.
Note
This is only available for the 2D case.
- Parameters
os – The out stream to write to
w – The width of the output SVG
h – The height of the output SVG
far_distance – The distance to the virtual “far line” at which point the side lines terminate visually.
unit – Multiplicative factor to apply to internal distances
-
Frustum<value_t, DIM, SIDES> transformed(const transform_type &trf) const
Transforms this frustum using a given transform and returns a new instance.
- Parameters
trf – The transform to apply
- Returns
A copy of this frustum with the transform
trf
applied.
-
class FsmwMode1dFinder
- #include <Acts/Vertexing/FsmwMode1dFinder.hpp>
Calculates the mode of a unidimenensional distribution using the Fraction of Sample Mode with Weights algorithm For reference, see: On a Fast, Robust Estimator of the Mode: Comparisons to Other Robust Estimators with Applications, David R.
Bickel, Rudolf Fruehwirth, arXiv:math/0505419 It’s like an iterative “Half Sample Mode”, but the fraction you take at each step can be configured by the user. Configuration possibilities: (1) fraction (default is 50 %) (2) firstFraction (default is 50 %)
Public Functions
-
FsmwMode1dFinder() = default
Default constructor.
-
FsmwMode1dFinder(double firstFraction, double fraction)
Overload constructor.
- Parameters
firstFraction – first fraction in FSMW algorithm
fraction – all other fractions in FSMW algorithm
-
Result<double> getMode(std::vector<std::pair<double, double>> inputVector) const
Function to calculate mode with FSMW algorithm.
- Parameters
inputVector – Input collection to calculate mode from
- Returns
mode value
-
FsmwMode1dFinder() = default
-
template<typename input_track_t, typename linearizer_t>
class FullBilloirVertexFitter - #include <Acts/Vertexing/FullBilloirVertexFitter.hpp>
Vertex fitter class implementing the Billoir vertex fitter.
This class implements the Billoir vertex fitter:
Fast vertex fitting with a local parametrization of tracks Author(s) Billoir, P ; Qian, S In: Nucl. Instrum. Methods Phys. Res., A 311 (1992) 139-150 DOI 10.1016/0168-9002(92)90859-3
- Template Parameters
input_track_t – Track object type
linearizer_t – Track linearizer type
Public Types
-
using InputTrack_t = input_track_t
-
using Linearizer_t = linearizer_t
-
using Propagator_t = typename linearizer_t::Propagator_t
Public Functions
-
template<typename T = input_track_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline FullBilloirVertexFitter(const Config &cfg) Constructor used if input_track_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
-
inline FullBilloirVertexFitter(const Config &cfg, std::function<BoundTrackParameters(input_track_t)> func)
Constructor for user-defined input_track_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from input_track_t object
-
Result<Vertex<input_track_t>> fit(const std::vector<const input_track_t*> ¶mVector, const linearizer_t &linearizer, const VertexingOptions<input_track_t> &vertexingOptions, State &state) const
Fit method, fitting vertex for provided tracks with constraint.
- Parameters
paramVector – Vector of track objects to fit vertex to
linearizer – The track linearizer
vertexingOptions – Vertexing options
state – The state object
- Returns
Fitted vertex
-
struct Config
- #include <Acts/Vertexing/FullBilloirVertexFitter.hpp>
Public Members
-
int maxIterations = 5
Maximum number of interations in fitter.
-
int maxIterations = 5
-
struct State
- #include <Acts/Vertexing/FullBilloirVertexFitter.hpp>
Public Functions
-
inline State(MagneticFieldProvider::Cache fieldCache)
The state constructor.
- Parameters
fieldCache – The magnetic field cache
Public Members
-
Linearizer_t::State linearizerState
The linearizer state.
-
inline State(MagneticFieldProvider::Cache fieldCache)
-
class GainMatrixSmoother
- #include <Acts/TrackFitting/GainMatrixSmoother.hpp>
Kalman trajectory smoother based on gain matrix formalism.
This implements not a single smoothing step, but the full backwards smoothing procedure for a filtered, forward trajectory using the stored linearization.
Public Types
-
using GetCovariance = Acts::Delegate<TrackStateTraits<MultiTrajectoryTraits::MeasurementSizeMax, false>::Covariance(void*)>
-
using GetParameters = Acts::Delegate<TrackStateTraits<MultiTrajectoryTraits::MeasurementSizeMax, false>::Parameters(void*)>
Public Functions
-
Result<void> calculate(void *ts, void *prev_ts, const GetParameters &filtered, const GetCovariance &filteredCovariance, const GetParameters &smoothed, const GetParameters &predicted, const GetCovariance &predictedCovariance, const GetCovariance &smoothedCovariance, const GetCovariance &jacobian, LoggerWrapper logger) const
-
template<typename D>
inline Result<void> operator()(const GeometryContext &gctx, MultiTrajectory<D> &trajectory, size_t entryIndex, LoggerWrapper logger = getDummyLogger()) const Run the Kalman smoothing for one trajectory.
- Parameters
gctx – [in] The geometry context for the smoothing
trajectory – [inout] The trajectory to be smoothed
entryIndex – [in] The index of state to start the smoothing
logger – [in] Where to write logging information to
-
using GetCovariance = Acts::Delegate<TrackStateTraits<MultiTrajectoryTraits::MeasurementSizeMax, false>::Covariance(void*)>
-
class GainMatrixUpdater
- #include <Acts/TrackFitting/GainMatrixUpdater.hpp>
Kalman update step using the gain matrix formalism.
Public Functions
Run the Kalman update step for a single trajectory state.
- Template Parameters
kMeasurementSizeMax –
- Parameters
gctx – [in] The current geometry context object, e.g. alignment
trackState – [inout] The track state
direction – [in] The navigation direction
logger – [in] Where to write logging information to
-
template<int mainGridSize = 2000, int trkGridSize = 15>
class GaussianGridTrackDensity - #include <Acts/Vertexing/GaussianGridTrackDensity.hpp>
Implements a 1-dim density grid to be filled with track Gaussian distributions.
Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density.
- Template Parameters
mainGridSize – The size of the z-axis 1-dim main density grid
trkGridSize – The 2(!)-dim grid size of a single track, i.e. a single track is modelled as a (trkGridSize x trkGridSize) grid in the d0-z0 plane. Note: trkGridSize has to be an odd value.
Public Types
-
using MainGridVector = Eigen::Matrix<float, mainGridSize, 1>
-
using TrackGridVector = Eigen::Matrix<float, trkGridSize, 1>
Public Functions
-
inline GaussianGridTrackDensity(const Config &cfg)
-
std::pair<int, TrackGridVector> addTrack(const BoundTrackParameters &trk, MainGridVector &mainGrid) const
Adds a single track to the overall grid density.
- Parameters
trk – The track to be added
mainGrid – The main 1-dim density grid along the z-axis
- Returns
A pair storing information about the z-bin position the track was added (int) and the 1-dim density contribution of the track itself
-
Result<float> getMaxZPosition(MainGridVector &mainGrid) const
Returns the z position of maximum track density.
- Parameters
mainGrid – The main 1-dim density grid along the z-axis
- Returns
The z position of maximum track density
-
Result<std::pair<float, float>> getMaxZPositionAndWidth(MainGridVector &mainGrid) const
Returns the z position of maximum track density and the estimated width.
- Parameters
mainGrid – The main 1-dim density grid along the z-axis
- Returns
The z position of maximum track density and width
-
void removeTrackGridFromMainGrid(int zBin, const TrackGridVector &trkGrid, MainGridVector &mainGrid) const
Removes a track from the overall grid density.
- Parameters
zBin – The center z-bin position the track needs to be removed from
trkGrid – The 1-dim density contribution of the track
mainGrid – The main 1-dim density grid along the z-axis
-
struct Config
- #include <Acts/Vertexing/GaussianGridTrackDensity.hpp>
The configuration struct.
Public Functions
-
inline Config(float zMinMax_ = 100)
Note
The value of
zMinMax_
together withmainGridSize
determines the overall bin size to be used as seen below- Parameters
zMinMax_ – The minimum and maximum z-values (in mm) that should be covered by the main 1-dim density grid along the z-axis
Public Members
-
float binSize
-
float maxRelativeDensityDev = 0.01
-
bool useHighestSumZPosition = false
-
float zMinMax
-
inline Config(float zMinMax_ = 100)
-
template<typename propagator_t, typename traj_t, typename bethe_heitler_approx_t = detail::BetheHeitlerApprox<6, 5>>
struct GaussianSumFitter - #include <Acts/TrackFitting/GaussianSumFitter.hpp>
Gaussian Sum Fitter implementation.
Note
This GSF implementation tries to be as compatible to the KalmanFitter as possible. However, there are certain differences at the moment:
There is always a backward pass during fitting.
There are only measurement states in the result
Passed-again-surfaces is always empty at the moment
Probably some more differences which I don’t think of at the moment.
- Template Parameters
propagator_t – The propagator type on which the algorithm is built on
bethe_heitler_approx_t – The type of the Bethe-Heitler-Approximation
Public Types
-
using GsfActor = detail::GsfActor<bethe_heitler_approx_t, traj_t>
The actor type.
The navigator type.
Public Functions
-
inline GaussianSumFitter(propagator_t &&propagator, bethe_heitler_approx_t &&bha = bethe_heitler_approx_t(detail::bh_cdf_cmps6_order5_data))
The fit function for the Direct navigator.
The fit function for the standard navigator.
The generic implementation of the fit function.
TODO check what this function does with the referenceSurface is e.g. the first measuerementSurface
Public Members
-
bethe_heitler_approx_t m_bethe_heitler_approx
The fitter holds the instance of the bethe heitler approx.
-
propagator_t m_propagator
The propagator instance used by the fit function.
-
template<typename input_track_t>
class GaussianTrackDensity - #include <Acts/Vertexing/GaussianTrackDensity.hpp>
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)
Public Functions
-
GaussianTrackDensity() = default
Default constructor.
-
inline GaussianTrackDensity(const Config &cfg)
Constructor with config.
-
double globalMaximum(State &state, const std::vector<const input_track_t*> &trackList, const std::function<BoundTrackParameters(input_track_t)> &extractParameters) const
Calculates the z position of the global maximum.
- Parameters
state – The track density state
trackList – All input tracks
extractParameters – Function extracting BoundTrackParameters from InputTrack
- Returns
z position of the global maximum
-
std::pair<double, double> globalMaximumWithWidth(State &state, const std::vector<const input_track_t*> &trackList, const std::function<BoundTrackParameters(input_track_t)> &extractParameters) const
Calculates z position of global maximum with Gaussian width for density function.
Strategy: The global maximum must be somewhere near a track. Since we can calculate the first and second derivatives, at each point we can determine a) whether the function is curved up (minimum) or down (maximum) b) the distance to nearest maximum, assuming either Newton (parabolic) or Gaussian local behavior. For each track where the second derivative is negative, find step to nearest maximum, take that step and then do one final refinement. The largest density encountered in this procedure (after checking all tracks) is considered the maximum.
- Parameters
state – The track density state
trackList – All input tracks
extractParameters – Function extracting BoundTrackParameters from InputTrack
- Returns
Pair of position of global maximum and Gaussian width
-
struct Config
- #include <Acts/Vertexing/GaussianTrackDensity.hpp>
The Config struct.
Public Functions
-
inline Config(double d0Sig = 3.5, double z0Sig = 12.)
Public Members
-
double d0MaxSignificance
-
double d0SignificanceCut
-
bool isGaussianShaped = true
-
double z0MaxSignificance
-
double z0SignificanceCut
-
inline Config(double d0Sig = 3.5, double z0Sig = 12.)
-
struct State
- #include <Acts/Vertexing/GaussianTrackDensity.hpp>
The State struct.
Public Functions
-
inline State(unsigned int nTracks)
Public Members
-
std::vector<TrackEntry> trackEntries
-
inline State(unsigned int nTracks)
-
struct TrackEntry
- #include <Acts/Vertexing/GaussianTrackDensity.hpp>
Struct to store information for a single track.
Public Functions
-
TrackEntry() = default
Default constructor.
-
inline TrackEntry(double z_, double c0_, double c1_, double c2_, double lowerBound_, double upperBound_)
Constructor initializing all members.
- Parameters
z_ – Trial z position
c0_ – z-independent term in exponent
c1_ – Linear coefficient in exponent
c2_ – Quadratic coefficient in exponent
lowerBound_ – The lower bound
upperBound_ – The upper bound
Public Members
-
double c0 = 0
-
double c1 = 0
-
double c2 = 0
-
double lowerBound = 0
-
double upperBound = 0
-
double z = 0
-
TrackEntry() = default
-
GaussianTrackDensity() = default
-
class GenericApproachDescriptor : public Acts::ApproachDescriptor
- #include <Acts/Geometry/GenericApproachDescriptor.hpp>
Class to decide and return which approaching surface to be taken, it’s a generic descriptor for n surfaces.
It is templated in order to allow for BoundarySurfaces from representing volumes of layers to be re-used
Public Functions
A generic approach descriptor for new Acts::Surface objects passing ownership.
- Parameters
aSurfaces – are the approach surfaces
-
~GenericApproachDescriptor() override = default
A generic approach descriptor with n surfaces to test.
-
virtual ObjectIntersection<Surface> approachSurface(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck) const override
Get the aproach surface to the layer.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The global position to start the approach from
direction – The momentum vector
bcheck – The boundary check prescription
- Returns
: a SurfaceIntersection
-
virtual const std::vector<const Surface*> &containedSurfaces() const override
return all contained surfaces of this approach descriptor
-
virtual std::vector<const Surface*> &containedSurfaces() override
Non-const version.
-
virtual void registerLayer(const Layer &lay) override
Register the Layer to the surfaces.
- Parameters
lay – is the layer to be registerd
-
class GenericCuboidVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/GenericCuboidVolumeBounds.hpp>
Public Functions
-
GenericCuboidVolumeBounds() = delete
-
GenericCuboidVolumeBounds(const std::array<Acts::Vector3, 8> &vertices) noexcept(false)
Constructor from a set of vertices.
The ordering is considered to be:
the first 4 vertices are the “top” face
the second 4 vertices are the “bottom” face
both faces are given in counter clock wise order
- Parameters
vertices – The set of input vertices
-
GenericCuboidVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor from a fixed size array.
- Parameters
values – The input values
-
~GenericCuboidVolumeBounds() override = default
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
void draw(IVisualization3D &helper, const Transform3 &transform = Transform3::Identity()) const
Draw this shape using a visualization helper.
- Parameters
helper – The visualizatin helper
transform – Optional transformation matrix
-
virtual bool inside(const Vector3 &gpos, double tol = 0.) const override
Checking if position given in volume frame is inside.
- Parameters
gpos – is the global position to be checked
tol – is the tolerance applied for the inside check
- Returns
boolean indicating if the position is inside
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const override
- Parameters
sl – is the output stream to be written into
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
Public Static Attributes
-
static constexpr size_t eSize = 24
-
GenericCuboidVolumeBounds() = delete
-
template<typename value_t>
class GeometryHierarchyMap - #include <Acts/Geometry/GeometryHierarchyMap.hpp>
Store values mapped into the geometry hierarchy.
The core functionality is to find an equivalent element, i.e. an identifier-value pair, for a given geometry identifier via
auto it = container.find(GeometryIdentifier(...)); if (it != container.end()) { ... }
Trailing zero levels of stored geometry identifiers are used as broadcast values to refer to higher-level objects within the geometry, e.g. a geometry identifier with vanishing approach and sensitive index identifies a layer. An entry will all geometry identifier levels set to zero acts as the global default value.
The container also supports range-based iteration over all stored elements
for (const auto& element : container) { ... }
and index-based access to stored elements and associated geometry identifiers
GeometryIdentifier id3 = container.idAt(3); const auto& element4 = container.valueAt(4);
Adding elements is potentially expensive as the internal lookup structure must be updated. In addition, modifying an element in-place could change its identifier which would also break the lookup. Thus, the container can not be modified after construction to prevent misuse.
Note
No guarantees are given for the element order when using range-based or index-based access. Any apparent ordering must be considered an implementation detail and might change.
- Template Parameters
value_t – stored value type
Public Types
-
using InputElement = typename std::pair<GeometryIdentifier, value_t>
Combined geometry identifier and value element. Only used for input.
-
using Iterator = typename std::vector<value_t>::const_iterator
-
using Size = typename std::vector<value_t>::size_type
-
using Value = value_t
Public Functions
-
inline GeometryHierarchyMap(std::vector<InputElement> elements)
Construct the container from the given elements.
- Parameters
elements – input elements (must be unique with respect to identifier)
-
inline GeometryHierarchyMap(std::initializer_list<InputElement> elements)
Construct the container from an initializer list.
- Parameters
elements – input initializer list
-
GeometryHierarchyMap() = default
-
GeometryHierarchyMap(const GeometryHierarchyMap&) = default
-
GeometryHierarchyMap(GeometryHierarchyMap&&) = default
-
~GeometryHierarchyMap() = default
-
inline Iterator begin() const
Return an iterator pointing to the beginning of the stored values.
-
inline bool empty() const
Check if any elements are stored.
-
inline Iterator end() const
Return an iterator pointing to the end of the stored values.
-
inline Iterator find(GeometryIdentifier id) const
Find the most specific value for a given geometry identifier.
This can be either from the element matching exactly to the given geometry id, if it exists, or from the element for the next available higher level within the geometry hierachy.
- Parameters
id – geometry identifier for which information is requested
- Return values
iterator – to an existing value
<tt>.end()</tt> – iterator if no matching element exists
-
inline GeometryIdentifier idAt(Size index) const
Access the geometry identifier for the i-th element with bounds check.
- Throws
std::out_of_range – for invalid indices
-
GeometryHierarchyMap &operator=(const GeometryHierarchyMap&) = default
-
GeometryHierarchyMap &operator=(GeometryHierarchyMap&&) = default
-
inline Size size() const
Return the number of stored elements.
-
template<typename value_t>
class GeometryHierarchyMapJsonConverter - #include <Acts/Plugins/Json/GeometryHierarchyMapJsonConverter.hpp>
Convert a geometry hierarchy map to/from Json.
The value type is expected to be directly convertible to/from a Json object. It has to be either a fundamental type or appropriate
to_json(json&, const value_t&)
andfrom_json(const json&, value_t&)
functions must be available. See the relevant nlohmann::json documentation for further information.A user-defined identifier is stored in the encoded Json object that is used to identify which value type is stored in the file. The identifier is checked for consistency when decoding the Json object.
- Template Parameters
value_t – value type stored in the geometry hierarchy map
Public Functions
-
inline GeometryHierarchyMapJsonConverter(std::string valueIdentifier)
Construct the converter.
- Parameters
valueIdentifier – user-defined identifier for the stored value
-
Container fromJson(const nlohmann::json &encoded) const
Decode a Json object into a geometry hierarchy map.
- Parameters
encoded – Json object that should be decoded
- Throws
std::invalid_argument – in case of format errors
- Returns
Decoded geometry hierarchy map
-
nlohmann::json toJson(const Container &container) const
Encode the geometry hierarchy map into a Json object.
- Parameters
container – Geometry hierarchy map that should be encoded
- Returns
Encoded Json object
-
class GeometryIdentifier
- #include <Acts/Geometry/GeometryIdentifier.hpp>
Identifier for geometry nodes within the geometry hierarchy.
An identifier can be split into the following components. They define a hierarchy of objects starting from the high-level volumes:
Volume
Boundary surfaces (for a volume)
Layers (confined within a volume)
Approach surfaces (for a layer)
Sensitive surfaces (confined to a layer, also called modules)
Public Types
-
using Value = uint64_t
Public Functions
-
inline constexpr GeometryIdentifier(Value encoded)
Construct from an already encoded value.
-
GeometryIdentifier() = default
Construct default GeometryIdentifier with all values set to zero.
-
GeometryIdentifier(GeometryIdentifier&&) = default
-
GeometryIdentifier(const GeometryIdentifier&) = default
-
~GeometryIdentifier() = default
-
inline constexpr Value approach() const
Return the approach identifier.
-
inline constexpr Value boundary() const
Return the boundary identifier.
-
inline constexpr Value extra() const
Return the extra identifier Usage can be experiment-specific, like tagging which kind of detector a surface object corresponds to, or which subsystem it belongs to.
-
inline constexpr Value layer() const
Return the layer identifier.
-
GeometryIdentifier &operator=(GeometryIdentifier&&) = default
-
GeometryIdentifier &operator=(const GeometryIdentifier&) = default
-
inline constexpr Value sensitive() const
Return the sensitive identifier.
-
inline constexpr GeometryIdentifier &setApproach(Value approach)
Set the approach identifier.
-
inline constexpr GeometryIdentifier &setBoundary(Value boundary)
Set the boundary identifier.
-
inline constexpr GeometryIdentifier &setExtra(Value extra)
Set the extra identifier.
-
inline constexpr GeometryIdentifier &setLayer(Value layer)
Set the layer identifier.
-
inline constexpr GeometryIdentifier &setSensitive(Value sensitive)
Set the sensitive identifier.
-
inline constexpr GeometryIdentifier &setVolume(Value volume)
Set the volume identifier.
-
inline constexpr Value value() const
Return the encoded value.
-
inline constexpr Value volume() const
Return the volume identifier.
-
class GeometryObject
- #include <Acts/Geometry/GeometryObject.hpp>
Base class to provide GeometryIdentifier interface:
simple set and get
It also provides the binningPosition method for Geometry geometrical object to be binned in BinnedArrays
Subclassed by Acts::Layer, Acts::Surface, Acts::Volume
Public Functions
-
GeometryObject() = default
Defaulted construrctor.
-
GeometryObject(const GeometryObject&) = default
Defaulted copy constructor.
-
inline GeometryObject(const GeometryIdentifier &geometryId)
Constructor from a value.
- Parameters
geometryId – the geometry identifier of the object
-
inline void assignGeometryId(const GeometryIdentifier &geometryId)
Set the value.
- Parameters
geometryId – the geometry identifier to be assigned
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const = 0
Force a binning position method.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the value in which you want to bin
- Returns
vector 3D used for the binning schema
-
inline virtual double binningPositionValue(const GeometryContext &gctx, BinningValue bValue) const
Implement the binningValue.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the dobule in which you want to bin
- Returns
float to be used for the binning schema
-
inline const GeometryIdentifier &geometryId() const
- Returns
the geometry id by reference
-
inline GeometryObject &operator=(const GeometryObject &geometryId)
Assignment operator.
- Parameters
geometryId – the source geometryId
-
template<class T>
class GeometryObjectSorterT - #include <Acts/Geometry/GeometryObjectSorter.hpp>
Public Functions
Constructor from a binning value.
- Parameters
gctx – The geometry context to use
bValue – is the value in which the binning is done
transform – is an optional transform to be performed
-
struct GeometryView3D
- #include <Acts/Visualization/GeometryView3D.hpp>
Public Static Functions
-
static void drawArrowBackward(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, double arrowLength, double arrowWidth, const ViewConfig &viewConfig = s_viewLine)
Convenience function : arrow pointing back.
- Parameters
helper – [inout] The visualization helper
start – The start point
end – The end point
arrowLength – wrt thickness
arrowWidth – wrt thickness
viewConfig – The drawing configuration for this segment
-
static void drawArrowForward(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, double arrowLength, double arrowWidth, const ViewConfig &viewConfig = s_viewLine)
Convenience function : arrow pointing forwad.
- Parameters
helper – [inout] The visualization helper
start – The start point
end – The end point
arrowLength – wrt thickness
arrowWidth – wrt thickness
viewConfig – The drawing configuration for this segment
-
static void drawArrowsBoth(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, double arrowLength, double arrowWidth, const ViewConfig &viewConfig = s_viewLine)
Convenience function : arrow pointing both directions.
- Parameters
helper – [inout] The visualization helper
start – The start point
end – The end point
arrowLength – wrt thickness
arrowWidth – wrt thickness
viewConfig – The drawing configuration for this segment
-
static void drawLayer(IVisualization3D &helper, const Layer &layer, const GeometryContext &gctx, const ViewConfig &layerConfig = s_viewPassive, const ViewConfig &sensitiveConfig = s_viewSensitive, const ViewConfig &gridConfig = s_viewGrid, const std::string &outputDir = ".")
Helper method to draw AbstractVolume objects.
- Parameters
helper – [inout] The visualization helper
layer – The tracking layer to be drawn
gctx – The geometry context for which it is drawn
layerConfig – The drawing configuration for passive surfaces
sensitiveConfig – The drawing configuration for sensitive surfaces
gridConfig – The drawing configuraiton for grid display
outputDir – Directory to write to
-
static void drawPolyhedron(IVisualization3D &helper, const Polyhedron &polyhedron, const ViewConfig &viewConfig = s_viewVolume)
Helper method to draw Polyhedron objects.
- Parameters
helper – [inout] The visualization helper
polyhedron – The surface to be drawn
viewConfig – The drawing configuration
-
static void drawSegment(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, const ViewConfig &viewConfig = s_viewLine)
Convenience function : line.
- Parameters
helper – [inout] The visualization helper
start – The start point
end – The end point
viewConfig – The drawing configuration for this segment
-
static void drawSegmentBase(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, int arrows = 0, double arrowLength = 0., double arrowWidth = 0., const ViewConfig &viewConfig = s_viewLine)
Helper method to draw lines - base for all lines.
- Parameters
helper – [inout] The visualization helper
start – The start point
end – The end point
arrows – [ -1 | 0 | 1 | 2 ] = [ start | none | end | both ]
arrowLength – wrt halflength
arrowWidth – wrt thickness
viewConfig – The drawing configuration for this segment
-
static void drawSurface(IVisualization3D &helper, const Surface &surface, const GeometryContext &gctx, const Transform3 &transform = Transform3::Identity(), const ViewConfig &ViewConfig = s_viewSensitive)
Helper method to draw Surface objects.
- Parameters
helper – [inout] The visualization helper
surface – The surface to be drawn
gctx – The geometry context for which it is drawn
transform – An option additional transform
ViewConfig – The drawing configuration
-
static void drawSurfaceArray(IVisualization3D &helper, const SurfaceArray &surfaceArray, const GeometryContext &gctx, const Transform3 &transform = Transform3::Identity(), const ViewConfig &sensitiveConfig = s_viewSensitive, const ViewConfig &passiveConfig = s_viewPassive, const ViewConfig &gridConfig = s_viewGrid, const std::string &outputDir = ".")
Helper method to draw SurfaceArray objects.
- Parameters
helper – [inout] The visualization helper
surfaceArray – The surface to be drawn
gctx – The geometry context for which it is drawn
transform – An option additional transform
sensitiveConfig – The drawing configuration for sensitive surfaces
passiveConfig – The drawing configuration for passive surfaces
gridConfig – The drawing configuraiton for grid
outputDir – Directory to write to
-
static void drawTrackingVolume(IVisualization3D &helper, const TrackingVolume &tVolume, const GeometryContext &gctx, const ViewConfig &containerView = s_viewVolume, const ViewConfig &volumeView = s_viewVolume, const ViewConfig &layerView = s_viewPassive, const ViewConfig &sensitiveView = s_viewSensitive, const ViewConfig &gridView = s_viewGrid, bool writeIt = true, const std::string &tag = "", const std::string &outputDir = ".")
Helper method to draw AbstractVolume objects.
- Parameters
helper – [inout] The visualization helper
tVolume – The tracking volume to be drawn
gctx – The geometry context for which it is drawn
containerView – The drawing configuration for a container volume
volumeView – The drawing configuration for the navigation level volume
layerView – The drawing configuration for passive surfaces
sensitiveView – The drawing configuration for sensitive surfaces
gridView – The drawing configuraiton for grid display
writeIt – The prescription to write it or not
tag – The (optional) additional output tag
outputDir – Directory to write to
-
static void drawVolume(IVisualization3D &helper, const AbstractVolume &volume, const GeometryContext &gctx, const Transform3 &transform = Transform3::Identity(), const ViewConfig &viewConfig = s_viewVolume)
Helper method to draw AbstractVolume objects.
- Parameters
helper – [inout] The visualization helper
volume – The volume to be drawn
gctx – The geometry context for which it is drawn
transform – An option additional transform
viewConfig – The drawing configuration for boundary surfaces
-
static void drawArrowBackward(IVisualization3D &helper, const Vector3 &start, const Vector3 &end, double arrowLength, double arrowWidth, const ViewConfig &viewConfig = s_viewLine)
-
class GlueVolumesDescriptor
- #include <Acts/Geometry/GlueVolumesDescriptor.hpp>
Descriptor class to hold GlueVolumes of a TrackingGeometry object.
Should ease the wrapping of a TrackingGeometry object describing one Detector by another one.
Public Functions
-
GlueVolumesDescriptor() = default
Constructor.
Constructor - with arguments.
- Parameters
gvs – are the glue volume arrays mapped to the volume faces
-
~GlueVolumesDescriptor() = default
Desctructor.
-
inline const std::vector<BoundarySurfaceFace> &glueFaces() const
Retrieve the available Glue Faces.
- Returns
the list of faces for which glue information is there
-
std::shared_ptr<const TrackingVolumeArray> glueVolumes(BoundarySurfaceFace bsf) const
Retrieve the glue volumes.
- Parameters
bsf – is the boundary surface face for which you want to get the array
- Returns
the shared pointer to the TrackingVolume array
Register the volumes.
- Parameters
bsf – is the boundary surface face where the volume array is attached
gvs – is the array of volumes to be attached
-
std::string screenOutput() const
Dump it to the screen.
-
GlueVolumesDescriptor() = default
-
template<int mainGridSize = 2000, int trkGridSize = 15, typename vfitter_t = DummyVertexFitter<>>
class GridDensityVertexFinder - #include <Acts/Vertexing/GridDensityVertexFinder.hpp>
Vertex finder that makes use of a track density grid.
Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density grid) a superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate.
- Template Parameters
mainGridSize – The size of the z-axis 1-dim main density grid
trkGridSize – The 2(!)-dim grid size of a single track, i.e. a single track is modelled as a (trkGridSize x trkGridSize) grid in the d0-z0 plane. Note: trkGridSize has to be an odd value.
Public Types
-
using MainGridVector = typename GridDensity::MainGridVector
-
using TrackGridVector = typename GridDensity::TrackGridVector
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline GridDensityVertexFinder(const Config &cfg) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline GridDensityVertexFinder() Default constructor used if InputTrack_t type == BoundTrackParameters.
-
inline GridDensityVertexFinder(const Config &cfg, const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
-
inline GridDensityVertexFinder(const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters with default Config object.
- Parameters
func – Function extracting BoundTrackParameters from InputTrack_t object
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &trackVector, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Function that finds single vertex candidate.
- Parameters
trackVector – Input track collection
vertexingOptions – Vertexing options
state – The state object to cache the density grid and density contributions of each track, to be used if cacheGridStateForTrackRemoval == true
- Returns
Vector of vertices, filled with a single vertex (for consistent interfaces)
-
struct Config
- #include <Acts/Vertexing/GridDensityVertexFinder.hpp>
The Config struct.
Public Functions
-
inline Config(float zMinMax = 100)
- Parameters
zMinMax – min and max z value of big z-axis grid
-
inline Config(const GridDensity &gDensity)
- Parameters
gDensity – The grid density
Public Members
-
bool cacheGridStateForTrackRemoval = true
-
double d0SignificanceCut = maxD0TrackSignificance * maxD0TrackSignificance
-
bool estimateSeedWidth = false
-
GridDensity gridDensity
-
double maxD0TrackSignificance = 3.5
-
double maxZ0TrackSignificance = 12.
-
double z0SignificanceCut = maxZ0TrackSignificance * maxZ0TrackSignificance
-
inline Config(float zMinMax = 100)
-
struct State
- #include <Acts/Vertexing/GridDensityVertexFinder.hpp>
The State struct.
Only needed if cacheGridStateForTrackRemoval == true
Public Members
-
std::map<const InputTrack_t*, std::pair<int, TrackGridVector>> binAndTrackGridMap
-
bool isInitialized = false
-
MainGridVector mainGrid = MainGridVector::Zero()
-
std::map<const InputTrack_t*, bool> trackSelectionMap
-
std::vector<const InputTrack_t*> tracksToRemove
-
std::map<const InputTrack_t*, std::pair<int, TrackGridVector>> binAndTrackGridMap
-
template<typename traj_t>
struct GsfExtensions - #include <Acts/TrackFitting/GsfOptions.hpp>
The extensions needed for the GSF.
Public Types
-
using Calibrator = Delegate<void(const GeometryContext&, TrackStateProxy)>
-
using ConstTrackStateProxy = typename MultiTrajectory<traj_t>::ConstTrackStateProxy
-
using OutlierFinder = Delegate<bool(ConstTrackStateProxy)>
-
using TrackStateProxy = typename MultiTrajectory<traj_t>::TrackStateProxy
-
using Updater = Delegate<Result<void>(const GeometryContext&, TrackStateProxy, NavigationDirection, LoggerWrapper)>
Public Functions
-
inline GsfExtensions()
Default constructor which connects the default void components.
Public Members
-
Calibrator calibrator
The Calibrator is a dedicated calibration algorithm that allows to calibrate measurements using track information, this could be e.g.
sagging for wires, module deformations, etc.
-
OutlierFinder outlierFinder
Determines whether a measurement is supposed to be considered as an outlier.
-
Updater updater
The updater incorporates measurement information into the track parameters.
-
using Calibrator = Delegate<void(const GeometryContext&, TrackStateProxy)>
-
template<typename traj_t>
struct GsfOptions - #include <Acts/TrackFitting/GsfOptions.hpp>
Public Members
-
bool abortOnError = true
-
std::reference_wrapper<const CalibrationContext> calibrationContext
-
bool disableAllMaterialHandling = false
-
GsfExtensions<traj_t> extensions
-
std::reference_wrapper<const GeometryContext> geoContext
-
LoggerWrapper logger
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
-
std::size_t maxComponents = 4
-
PropagatorPlainOptions propagatorPlainOptions
-
const Surface *referenceSurface = nullptr
-
bool abortOnError = true
-
template<typename propagator_t, typename propagator_options_t = PropagatorOptions<>>
class HelicalTrackLinearizer - #include <Acts/Vertexing/HelicalTrackLinearizer.hpp>
Linearizes the measurement equation (dependance of track parameters on the vertex position and track momentum at vertex) at the vicinity of the user-provided linearization point.
The measurement equation is linearized in the following way:
q_k= A_k (x_k - x_0k) + B_k (p_k - p_0k) + c_k
where q_k are the parameters at perigee nearest to the lin point, x_k is the position of the vertex, p_k the track momentum at the vertex, and c_k is the constant term of expansion. A_k and B_k are matrices of derivatives, denoted hereafter as “positionJacobian” and “momentumJacobian” respectively.
Ref.(1) - CERN-THESIS-2010-027, Giacinto Piacquadio (Freiburg U.)
- Template Parameters
propagator_t – Propagator type
propagator_options_t – Propagator options type
Public Types
-
using Propagator_t = propagator_t
Public Functions
-
inline HelicalTrackLinearizer(const Config &config)
Constructor.
- Parameters
config – Configuration object
-
Result<LinearizedTrack> linearizeTrack(const BoundTrackParameters ¶ms, const Vector4 &linPoint, const Acts::GeometryContext &gctx, const Acts::MagneticFieldContext &mctx, State &state) const
Function that linearizes BoundTrackParameters at given linearization point.
- Parameters
params – Parameters to linearize
linPoint – Linearization point
gctx – The geometry context
mctx – The magnetic field context
state – The state object
- Returns
Linearized track
-
struct Config
- #include <Acts/Vertexing/HelicalTrackLinearizer.hpp>
Configuration struct.
Public Functions
@ Config constructor if magnetic field is present
- Parameters
bIn – The magnetic field
prop – The propagator
Config constructor without B field -> uses NullBField.
- Parameters
prop – The propagator
Public Members
-
std::shared_ptr<const MagneticFieldProvider> bField
-
double maxRho = 1e+15
-
double minQoP = 1e-15
-
std::shared_ptr<const Propagator_t> propagator
-
struct State
- #include <Acts/Vertexing/HelicalTrackLinearizer.hpp>
State struct.
Public Functions
-
inline State(MagneticFieldProvider::Cache fieldCacheIn)
The state constructor.
- Parameters
fieldCacheIn – The magnetic field cache
Public Members
-
MagneticFieldProvider::Cache fieldCache
Magnetic field cache.
-
inline State(MagneticFieldProvider::Cache fieldCacheIn)
-
class HomogeneousSurfaceMaterial : public Acts::ISurfaceMaterial
- #include <Acts/Material/HomogeneousSurfaceMaterial.hpp>
It extends the ISurfaceMaterial virutal base class to describe a simple homogeneous material on a surface.
Public Functions
-
HomogeneousSurfaceMaterial() = default
Default Constructor - defaulted.
-
HomogeneousSurfaceMaterial(const MaterialSlab &full, double splitFactor = 1., MappingType mappingType = MappingType::Default)
Explicit constructor.
- Parameters
full – are the full material properties
splitFactor – is the split for pre/post update
mappingType – is the type of surface mapping associated to the surface
-
HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial &hsm) = default
Copy Constructor.
- Parameters
hsm – is the source material
-
HomogeneousSurfaceMaterial(HomogeneousSurfaceMaterial &&hsm) = default
Copy Move Constructor.
- Parameters
hsm – is the source material
-
~HomogeneousSurfaceMaterial() override = default
Destructor.
-
inline virtual const MaterialSlab &materialSlab(const Vector2 &lp) const final
Return method for full material description of the Surface.
from local coordinate on the surface
Note
the input parameter is ignored
- Parameters
lp – is the local position used for the (eventual) lookup
- Returns
const MaterialSlab
-
inline virtual const MaterialSlab &materialSlab(const Vector3 &gp) const final
Return method for full material description of the Surface.
from the global coordinates
Note
the input parameter is ignored
- Parameters
gp – is the global position used for the (eventual) lookup
- Returns
const MaterialSlab
-
inline virtual const MaterialSlab &materialSlab(size_t bin0, size_t bin1) const final
Direct access via bins to the MaterialSlab.
Note
the input parameters are ignored
- Parameters
bin0 – is the material bin in dimension 0
bin1 – is the material bin in dimension 1
-
virtual HomogeneousSurfaceMaterial &operator*=(double scale) final
Scale operator.
it is effectively a thickness scaling
- Parameters
scale – is the scale factor
-
HomogeneousSurfaceMaterial &operator=(const HomogeneousSurfaceMaterial &hsm) = default
Assignment operator.
- Parameters
hsm – is the source material
-
HomogeneousSurfaceMaterial &operator=(HomogeneousSurfaceMaterial &&hsm) = default
Assignment Move operator.
- Parameters
hsm – is the source material
-
inline bool operator==(const HomogeneousSurfaceMaterial &hsm) const
Equality operator.
- Parameters
hsm – is the source material
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – The outoput stream
-
HomogeneousSurfaceMaterial() = default
-
class HomogeneousVolumeMaterial : public Acts::IVolumeMaterial
- #include <Acts/Material/HomogeneousVolumeMaterial.hpp>
It extends the IVolumeMaterial base class to describe a simple homogeneous material in a volume.
Public Functions
-
HomogeneousVolumeMaterial(const Material &material)
Explicit constructor.
- Parameters
material – is the material held by this
-
HomogeneousVolumeMaterial(const HomogeneousVolumeMaterial &hvm) = default
Copy Constructor.
- Parameters
hvm – is the source material
-
HomogeneousVolumeMaterial(HomogeneousVolumeMaterial &&hvm) = default
Copy Move Constructor.
- Parameters
hvm – is the source material
-
~HomogeneousVolumeMaterial() override = default
Destructor.
-
inline virtual const Material material(const Vector3 &position) const final
Access to actual material.
Note
position
is ignored- Parameters
position – is the request position for the material call
-
HomogeneousVolumeMaterial &operator=(const HomogeneousVolumeMaterial &hvm) = default
Assignment operator.
- Parameters
hvm – is the source material
-
inline bool operator==(const HomogeneousVolumeMaterial &hvm) const
Equality operator.
- Parameters
hvm – is the source material
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – The outoput stream
-
HomogeneousVolumeMaterial(const Material &material)
-
class IAxis
- #include <Acts/Utilities/IAxis.hpp>
Common base class for all Axis instance.
This allows generice handling such as for inspection.
Public Functions
-
virtual std::vector<ActsScalar> getBinEdges() const = 0
Return a vector of bin edges.
- Returns
Vector which contains the bin edges
-
virtual detail::AxisBoundaryType getBoundaryType() const = 0
returns the boundary type set in the template param
- Returns
AxisBoundaryType
of this axis
-
virtual ActsScalar getMax() const = 0
get maximum of binning range
- Returns
maximum of binning range
-
virtual ActsScalar getMin() const = 0
get minimum of binning range
- Returns
minimum of binning range
-
virtual size_t getNBins() const = 0
get total number of bins
- Returns
total number of bins (excluding under-/overflow bins)
-
virtual bool isEquidistant() const = 0
returns whether the axis is equidistant
- Returns
bool is equidistant
-
virtual bool isVariable() const = 0
returns whether the axis is variable
- Returns
bool is variable
-
virtual std::vector<ActsScalar> getBinEdges() const = 0
-
class IConfinedTrackingVolumeBuilder
- #include <Acts/Geometry/IConfinedTrackingVolumeBuilder.hpp>
This is an interface class for constructing TrackingVolumes whose are confined in a mother-TrackingVolume.
Subclassed by Acts::DD4hepVolumeBuilder
Public Functions
-
virtual ~IConfinedTrackingVolumeBuilder() = default
Virtual destructor.
-
virtual MutableTrackingVolumeVector centralVolumes() const = 0
Interface for constructing a vector of confined TrackingVolumes.
-
virtual const std::string &identification() const = 0
Interface for retreiving the identification string of the confined volumes.
-
virtual ~IConfinedTrackingVolumeBuilder() = default
-
class IdentifiedDetectorElement : public DetectorElementBase
- #include <Acts/Plugins/Identification/IdentifiedDetectorElement.hpp>
The identified detector element.
It adds the Identifier defnition and a forward declaration of the DigitizationModule to the detector elements
The identifier can be overwritten with by the use of the ACTS_CORE_IDENTIFIER_PLUGIN
Subclassed by Acts::TGeoDetectorElement
Public Functions
-
virtual const std::shared_ptr<const DigitizationModule> digitizationModule() const = 0
Retrieve the DigitizationModule.
-
virtual Identifier identifier() const = 0
Retrieve the Identifier.
-
virtual const std::shared_ptr<const DigitizationModule> digitizationModule() const = 0
-
struct Identity
- #include <Acts/Utilities/Identity.hpp>
Function object which maps a value to itself by perfect forwarding This is a backport of C++20’s std::identity.
Public Functions
-
template<typename T>
inline auto operator()(T &&v) const
-
template<typename T>
-
template<typename SpacePoint>
class IExperimentCuts - #include <Acts/Seeding/IExperimentCuts.hpp>
IExperimentCuts
can be used to increase or decrease seed weights based on the space points used in a seed.Seed weights are also influenced by the SeedFilter default implementation. This tool is also used to decide if a seed passes a seed weight cut. As the weight is stored in seeds, there are two distinct methods.
Public Functions
-
virtual ~IExperimentCuts() = default
-
virtual std::vector<std::pair<float, std::unique_ptr<const InternalSeed<SpacePoint>>>> cutPerMiddleSP(std::vector<std::pair<float, std::unique_ptr<const InternalSeed<SpacePoint>>>> seeds) const = 0
- Parameters
seeds – contains pairs of weight and seed created for one middle space point
- Returns
vector of seeds that pass the cut
-
virtual float seedWeight(const InternalSpacePoint<SpacePoint> &bottom, const InternalSpacePoint<SpacePoint> &middle, const InternalSpacePoint<SpacePoint> &top) const = 0
Returns seed weight bonus/malus depending on detector considerations.
- Parameters
bottom – bottom space point of the current seed
middle – middle space point of the current seed
top – top space point of the current seed
- Returns
seed weight to be added to the seed’s weight
-
virtual bool singleSeedCut(float weight, const InternalSpacePoint<SpacePoint> &bottom, const InternalSpacePoint<SpacePoint> &middle, const InternalSpacePoint<SpacePoint> &top) const = 0
- Parameters
weight – the current seed weight
bottom – bottom space point of the current seed
middle – middle space point of the current seed
top – top space point of the current seed
- Returns
true if the seed should be kept, false if the seed should be discarded
-
virtual ~IExperimentCuts() = default
-
class ILayerArrayCreator
- #include <Acts/Geometry/ILayerArrayCreator.hpp>
Interface class ILayerArrayCreators, it inherits from IAlgTool.
It receives the LayerVector and creaets an array with NaivgationLayer objects filled in between.
Subclassed by Acts::LayerArrayCreator
Public Functions
-
virtual ~ILayerArrayCreator() = default
Virtual destructor.
-
virtual std::unique_ptr<const LayerArray> layerArray(const GeometryContext &gctx, const LayerVector &layers, double min, double max, BinningType btype = arbitrary, BinningValue bvalue = binX) const = 0
LayerArrayCreator interface method.
- Parameters
gctx – is the geometry context for witch the volume is built
layers – are the layers to be moved into an array
min – is the minimul value for binning
max – is the maximum value for binning
btype – is the binning type
bvalue – is the value in which the binning should be done
- Returns
unqiue pointer to a new LayerArray
-
virtual ~ILayerArrayCreator() = default
-
class ILayerBuilder
- #include <Acts/Geometry/ILayerBuilder.hpp>
Interface class for ILayerBuilders in a typical | EC- | Central | EC+ | detector setup.
Subclassed by Acts::DD4hepLayerBuilder, Acts::PassiveLayerBuilder, Acts::TGeoLayerBuilder
Public Functions
-
virtual ~ILayerBuilder() = default
Virtual destructor.
-
virtual const LayerVector centralLayers(const GeometryContext &gctx) const = 0
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at the central sector
-
virtual const std::string &identification() const = 0
Name identification.
- Returns
the string based identification
-
virtual const LayerVector negativeLayers(const GeometryContext &gctx) const = 0
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at negative side
-
virtual const LayerVector positiveLayers(const GeometryContext &gctx) const = 0
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at positive side
-
virtual ~ILayerBuilder() = default
-
class IMaterialDecorator
- #include <Acts/Material/IMaterialDecorator.hpp>
Virtual base class for decorators that allow to load material onto a TrackingGeometry.
The geometry allows material to be assigned either to surfaces or to volumes, hence there are two decorate interface methots.
Subclassed by Acts::JsonMaterialDecorator
Public Functions
-
virtual ~IMaterialDecorator() = default
Virtual Destructor.
-
virtual void decorate(Surface &surface) const = 0
Decorate a surface.
- Parameters
surface – the non-cost surface that is decorated
-
virtual void decorate(TrackingVolume &volume) const = 0
Decorate a TrackingVolume.
- Parameters
volume – the non-cost volume that is decorated
-
virtual ~IMaterialDecorator() = default
-
struct ImpactParametersAndSigma
- #include <Acts/Vertexing/ImpactPointEstimator.hpp>
Public Members
-
double IPd0 = 0.
-
double IPz0 = 0.
-
double IPz0SinTheta = 0.
-
double PVsigmad0 = 0.
-
double PVsigmaz0 = 0.
-
double PVsigmaz0SinTheta = 0.
-
double sigmad0 = 0.
-
double sigmaz0 = 0.
-
double sigmaz0SinTheta = 0.
-
double IPd0 = 0.
-
template<typename input_track_t, typename propagator_t, typename propagator_options_t = PropagatorOptions<>>
class ImpactPointEstimator - #include <Acts/Vertexing/ImpactPointEstimator.hpp>
Estimator for impact point calculations.
Public Functions
-
inline ImpactPointEstimator(const Config &cfg)
Constructor.
- Parameters
cfg – Configuration object
-
Result<double> calculate3dDistance(const GeometryContext &gctx, const BoundTrackParameters &trkParams, const Vector3 &vtxPos, State &state) const
Calculates 3D distance between a track and a 3D point.
- Parameters
gctx – The geometry context
trkParams – Track parameters
vtxPos – Position to calculate distance to
state – The state object
- Returns
Distance
-
Result<std::unique_ptr<const BoundTrackParameters>> estimate3DImpactParameters(const GeometryContext &gctx, const Acts::MagneticFieldContext &mctx, const BoundTrackParameters &trkParams, const Vector3 &vtxPos, State &state) const
Creates track parameters bound to plane at point of closest approach in 3d to given reference position.
The parameters and errors are defined on the plane intersecting the track at point of closest approach, with track orthogonal to the plane and center of the plane defined as the given reference point (vertex).
- Parameters
gctx – The geometry context
mctx – The magnetic field context
trkParams – Track parameters
vtxPos – Reference position (vertex)
state – The state object
- Returns
New track params
-
Result<ImpactParametersAndSigma> estimateImpactParameters(const BoundTrackParameters &track, const Vertex<input_track_t> &vtx, const GeometryContext &gctx, const MagneticFieldContext &mctx) const
Estimates the impact parameters and their errors of a given track w.r.t.
a vertex by propagating the trajectory state towards the vertex position.
- Parameters
track – Track to estimate IP from
vtx – Vertex the track belongs to
gctx – The geometry context
mctx – The magnetic field context
-
Result<double> get3dVertexCompatibility(const GeometryContext &gctx, const BoundTrackParameters *trkParams, const Vector3 &vertexPos) const
Estimates the compatibility of a track to a vertex position based on the 3d distance between the track and the vertex.
- Parameters
gctx – The Geometry context
trkParams – Track parameters at point of closest approach in 3d as retrieved by estimate3DImpactParameters
vertexPos – The vertex position
- Returns
The compatibility value
-
struct Config
- #include <Acts/Vertexing/ImpactPointEstimator.hpp>
Public Functions
Config constructor if magnetic field is present.
- Parameters
bIn – The magnetic field
prop – The propagator
Config constructor without B field -> uses NullBField provided)
- Parameters
prop – The propagator
Public Members
-
std::shared_ptr<const MagneticFieldProvider> bField
Magnetic field.
-
int maxIterations = 20
Max. number of iterations in Newton method.
-
double maxRho = 1e+15
Maximum curvature value.
-
double minQoP = 1e-15
Minimum q/p value.
-
double precision = 1.e-10
Desired precision in deltaPhi in Newton method.
-
std::shared_ptr<const propagator_t> propagator
Propagator.
-
struct State
- #include <Acts/Vertexing/ImpactPointEstimator.hpp>
State struct.
Public Functions
-
inline State(MagneticFieldProvider::Cache fieldCacheIn)
The state constructor.
- Parameters
fieldCacheIn – The magnetic field cache
Public Members
-
MagneticFieldProvider::Cache fieldCache
Magnetic field cache.
-
inline State(MagneticFieldProvider::Cache fieldCacheIn)
-
inline ImpactPointEstimator(const Config &cfg)
-
class InfiniteBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/InfiniteBounds.hpp>
templated boundless extension to forward the interface Returns all inside checks to true and can templated for all bounds
Public Functions
-
InfiniteBounds() = default
-
~InfiniteBounds() override = default
-
inline virtual bool inside(const Vector2&, const BoundaryCheck&) const final
Method inside() returns true for any case.
ignores input parameters
- Returns
always true
-
inline virtual std::ostream &toStream(std::ostream &os) const final
Output Method for std::ostream.
-
inline virtual SurfaceBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.
- Returns
of the stored values for this SurfaceBounds object
-
InfiniteBounds() = default
-
template<typename SpacePoint>
class InternalSeed - #include <Acts/Seeding/InternalSeed.hpp>
Public Functions
-
InternalSeed(InternalSpacePoint<SpacePoint> &s0, InternalSpacePoint<SpacePoint> &s1, InternalSpacePoint<SpacePoint> &s2, float z, bool qualitySeed = false)
-
InternalSeed &operator=(const InternalSeed &seed)
-
inline bool qualitySeed() const
-
inline float z() const
Public Members
-
const std::array<InternalSpacePoint<SpacePoint>*, 3> sp
-
InternalSeed(InternalSpacePoint<SpacePoint> &s0, InternalSpacePoint<SpacePoint> &s1, InternalSpacePoint<SpacePoint> &s2, float z, bool qualitySeed = false)
-
template<typename SpacePoint>
class InternalSpacePoint - #include <Acts/Seeding/InternalSpacePoint.hpp>
Public Functions
-
InternalSpacePoint() = delete
-
inline InternalSpacePoint(const SpacePoint &sp, const Acts::Vector3 &globalPos, const Acts::Vector2 &offsetXY, const Acts::Vector2 &variance)
-
inline InternalSpacePoint(const InternalSpacePoint<SpacePoint> &sp)
-
~InternalSpacePoint() = default
-
inline const float &cotTheta() const
-
inline const float &deltaR() const
-
InternalSpacePoint<SpacePoint> &operator=(const InternalSpacePoint<SpacePoint>&) = delete
-
inline float phi() const
-
inline const float &quality() const
-
inline const float &radius() const
-
inline void setCotTheta(float cotTheta)
-
inline void setDeltaR(float deltaR)
-
inline void setQuality(float quality)
-
inline const SpacePoint &sp() const
-
inline const float &varianceR() const
-
inline const float &varianceZ() const
-
inline const float &x() const
-
inline const float &y() const
-
inline const float &z() const
-
InternalSpacePoint() = delete
-
template<typename grid_t>
class InterpolatedBFieldMap : public Acts::InterpolatedMagneticField - #include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
interpolate magnetic field value from field values on a given grid
This class implements a magnetic field service which is initialized by a field map defined by:
a list of field values on a regular grid in some n-Dimensional space,
a transformation of global 3D coordinates onto this n-Dimensional space.
a transformation of local n-Dimensional magnetic field coordinates into global (cartesian) 3D coordinates
The magnetic field value for a given global position is then determined by:
mapping the position onto the grid,
looking up the magnetic field values on the closest grid points,
doing a linear interpolation of these magnetic field values.
- Template Parameters
grid_t – The Grid type which provides the field storage and interpolation
Public Functions
-
inline InterpolatedBFieldMap(Config cfg)
default constructor
-
inline Result<Vector3> getField(const Vector3 &position) const
retrieve field at given position
- Parameters
position – [in] global 3D position
- Returns
magnetic field value at the given position
- Pre
The given
position
must lie within the range of the underlying magnetic field map.
-
inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const final
Retrieve magnetic field value at a given location.
Requires a cache object created through makeCache().
- Parameters
position – [in] global 3D position for the lookup
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector at given position
-
inline Result<FieldCell> getFieldCell(const Vector3 &position) const
retrieve field cell for given position
- Parameters
position – [in] global 3D position
- Returns
field cell containing the given global position
- Pre
The given
position
must lie within the range of the underlying magnetic field map.
-
inline virtual Result<Vector3> getFieldGradient(const Vector3 &position, ActsMatrix<3, 3> &derivative, MagneticFieldProvider::Cache &cache) const final
Retrieve magnetic field value its its gradient.
Requires a cache object created through makeCache().
Note
currently the derivative is not calculated
Note
Cache is not used currently
- Parameters
position – [in] global 3D position
derivative – [out] gradient of magnetic field vector as (3x3) matrix
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector
-
inline virtual Vector3 getFieldUnchecked(const Vector3 &position) const final
Get a field value without checking if the lookup position is within the interpolation domain.
- Parameters
position – The lookup position in 3D
- Returns
The field value at
position
-
inline const Grid &getGrid() const
Get a const reference on the underlying grid structure.
- Returns
grid reference
-
inline virtual std::vector<double> getMax() const final
get the maximum value of all axes of the field map
- Returns
vector returning the maxima of all field map axes
-
inline virtual std::vector<double> getMin() const final
get the minimum value of all axes of the field map
- Returns
vector returning the minima of all field map axes
-
inline virtual std::vector<size_t> getNBins() const final
get the number of bins for all axes of the field map
- Returns
vector returning number of bins for all field map axes
-
inline virtual bool isInside(const Vector3 &position) const final
check whether given 3D position is inside look-up domain
- Parameters
position – [in] global 3D position
- Returns
true
if position is inside the defined look-up grid, otherwisefalse
-
inline bool isInsideLocal(const ActsVector<DIM_POS> &gridPosition) const
check whether given 3D position is inside look-up domain
- Parameters
gridPosition – [in] local N-D position
- Returns
true
if position is inside the defined look-up grid, otherwisefalse
-
inline virtual MagneticFieldProvider::Cache makeCache(const MagneticFieldContext &mctx) const final
Make an opaque cache for the magnetic field.
Instructs the specific implementation to generate a
Cache
instance for magnetic field lookup.- Parameters
mctx – The magnetic field context to generate cache for
- Returns
Cache The opaque cache object
Public Static Attributes
-
static constexpr size_t DIM_POS = Grid::DIM
-
struct Cache
- #include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
Public Functions
-
inline Cache(const MagneticFieldContext &mctx)
Constructor with magnetic field context.
- Parameters
mctx – the magnetic field context
-
inline Cache(const MagneticFieldContext &mctx)
-
struct Config
- #include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
Config structure for the interpolated B field map.
Public Members
-
Grid grid
grid storing magnetic field values
-
double scale = 1.
global B-field scaling factor
Note
Negative values for
scale
are accepted and will invert the direction of the magnetic field.
-
std::function<Vector3(const FieldType&, const Vector3&)> transformBField
calculating the global 3D coordinates (cartesian) of the magnetic field with the local n dimensional field and the global 3D position as input
- std::function< ActsVector< DIM_POS >const Vector3 &)> transformPos
mapping of global 3D coordinates (cartesian) onto grid space
-
Grid grid
-
struct FieldCell
- #include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
struct representing smallest grid unit in magnetic field grid
This type encapsulate all required information to perform linear interpolation of magnetic field values within a confined 3D volume.
Public Functions
-
inline FieldCell(std::array<double, DIM_POS> lowerLeft, std::array<double, DIM_POS> upperRight, std::array<Vector3, N> fieldValues)
default constructor
- Parameters
lowerLeft – [in] generalized lower-left corner of hyper box (containing the minima of the hyper box along each Dimension)
upperRight – [in] generalized upper-right corner of hyper box (containing the maxima of the hyper box along each Dimension)
fieldValues – [in] field values at the hyper box corners sorted in the canonical order defined in Acts::interpolate
-
inline Vector3 getField(const ActsVector<DIM_POS> &position) const
retrieve field at given position
- Parameters
position – [in] global 3D position
- Returns
magnetic field value at the given position
- Pre
The given
position
must lie within the current field cell.
-
inline bool isInside(const ActsVector<DIM_POS> &position) const
check whether given 3D position is inside this field cell
- Parameters
position – [in] global 3D position
- Returns
true
if position is inside the current field cell, otherwisefalse
Public Static Attributes
-
static constexpr unsigned int N = 1 << DIM_POS
number of corner points defining the confining hyper-box
-
inline FieldCell(std::array<double, DIM_POS> lowerLeft, std::array<double, DIM_POS> upperRight, std::array<Vector3, N> fieldValues)
-
class InterpolatedMagneticField : public Acts::MagneticFieldProvider
- #include <Acts/MagneticField/InterpolatedBFieldMap.hpp>
Subclassed by Acts::InterpolatedBFieldMap< grid_t >
Public Functions
-
virtual Vector3 getFieldUnchecked(const Vector3 &position) const = 0
Get a field value without checking if the lookup position is within the interpolation domain.
- Parameters
position – The lookup position in 3D
- Returns
The field value at
position
-
virtual std::vector<double> getMax() const = 0
get the maximum value of all axes of the field map
- Returns
vector returning the maxima of all field map axes
-
virtual std::vector<double> getMin() const = 0
get the minimum value of all axes of the field map
- Returns
vector returning the minima of all field map axes
-
virtual std::vector<size_t> getNBins() const = 0
get the number of bins for all axes of the field map
- Returns
vector returning number of bins for all field map axes
-
virtual bool isInside(const Vector3 &position) const = 0
check whether given 3D position is inside look-up domain
- Parameters
position – [in] global 3D position
- Returns
true
if position is inside the defined look-up grid, otherwisefalse
-
virtual Vector3 getFieldUnchecked(const Vector3 &position) const = 0
-
template<typename Mapper_t>
class InterpolatedMaterialMap : public Acts::IVolumeMaterial - #include <Acts/Material/InterpolatedMaterialMap.hpp>
Interpolate material classification values from material values on a given grid.
This class implements a material service which is initialized by a material map defined by:
a list of material values on a regular grid in some n-Dimensional space,
a transformation of global 3D coordinates onto this n-Dimensional space.
a transformation of local n-Dimensional material coordinates into global (cartesian) 3D coordinates
The material value for a given global position is then determined by:
mapping the position onto the grid,
looking up the material classification values on the closest grid points,
doing a linear interpolation of these values.
Warning
Each classification number of the material is interpolated independently and thus does not consider any correlations that exists between these values. This might work out since the used material is already a mean of the materials in a certain bin and can therewith be treated as a collection of numbers.
- Template Parameters
G – Type of the grid
Public Functions
-
inline InterpolatedMaterialMap(Mapper_t &&mapper)
Create interpolated map.
- Parameters
mapper – [in] Material map
-
inline InterpolatedMaterialMap(Mapper_t &&mapper, BinUtility bu)
Create interpolated map.
- Parameters
mapper – [in] Material map
bu – [in]
BinUtility
for build from
-
inline const BinUtility &binUtility() const
Return the BinUtility.
-
inline const Mapper_t &getMapper() const
Convenience method to access underlying material mapper.
- Returns
The material mapper
-
inline Material getMaterial(const Vector3 &position) const
Retrieve the interpolated material.
- Parameters
position – [in] Global 3D position
- Returns
material at given position
-
inline Material getMaterial(const Vector3 &position, Cache &cache) const
Retrieve material.
- Parameters
position – [in] Global 3D position
cache – [inout] Cache object. Contains material cell used for interpolation
- Returns
material at given position
-
inline Material getMaterialGradient(const Vector3 &position, ActsMatrix<5, 5> &derivative) const
Retrieve material value & its “gradient”.
Note
Currently the derivative is not calculated
- Parameters
position – [in] Global 3D position
derivative – [out] “Gradient” of material as (5x5) matrix
- Returns
Material
-
inline Material getMaterialGradient(const Vector3 &position, ActsMatrix<5, 5> &derivative, Cache &cache) const
Retrieve material value & its “gradient”.
Note
Currently the derivative is not calculated
Note
Cache is not used currently
- Parameters
position – [in] Global 3D position
derivative – [out] “Gradient” of material as (5x5) matrix
cache – [inout] Cache object. Contains cell used for
- Returns
Material
-
inline bool isInside(const Vector3 &position) const
Check whether given 3D position is inside look-up domain.
- Parameters
position – [in] Global 3D position
- Returns
true
if position is inside the defined map, otherwisefalse
-
inline virtual const Material material(const Vector3 &position) const
Retrieve the binned material.
- Parameters
position – [in] Global 3D position
- Returns
Material at given position
-
inline virtual std::ostream &toStream(std::ostream &sl) const
Output Method for std::ostream.
- Parameters
sl – The outoput stream
-
struct Cache
- #include <Acts/Material/InterpolatedMaterialMap.hpp>
Temporary storage of a certain cell to improve material access.
Public Members
-
bool initialized = false
Boolean statement if the cell is initialized.
-
std::optional<typename Mapper_t::MaterialCell> matCell
Stored material cell.
-
bool initialized = false
-
template<unsigned int DIM>
struct Intersection - #include <Acts/Utilities/Intersection.hpp>
Intersection struct used for position.
Public Types
-
using Status = IntersectionStatus
Status enum.
Public Functions
-
inline Intersection(const ActsVector<DIM> &sinter, double slength, Status sstatus)
Constructor with arguments.
- Parameters
sinter – is the position of the intersection
slength – is the path length to the intersection
sstatus – is an enum indicating the status of the intersection
-
Intersection() = default
Default constructor.
-
inline explicit operator bool() const
Bool() operator for validity checking.
-
inline bool operator<(const Intersection<DIM> &si) const
Smaller operator for sorting,.
it respects the validity of the intersection
- Parameters
si – is the intersection for testing
-
inline bool operator>(const Intersection<DIM> &si) const
Greater operator for sorting,.
it respects the validity of the intersection
- Parameters
si – is the intersection for testing
Public Members
-
ActsVector<DIM>::Scalar pathLength{std::numeric_limits<double>::infinity()}
Signed path length to the intersection (if valid)
-
ActsVector<DIM> position = ActsVector<DIM>::Zero()
Position of the intersection.
-
using Status = IntersectionStatus
-
class ISurfaceMaterial
- #include <Acts/Material/ISurfaceMaterial.hpp>
Virtual base class of surface based material description.
MaterialSlab that are associated to a surface, extended by certain special representations (binned, homogenous)
Subclassed by Acts::BinnedSurfaceMaterial, Acts::HomogeneousSurfaceMaterial, Acts::ProtoSurfaceMaterial
Public Functions
-
ISurfaceMaterial() = default
Constructor.
-
inline ISurfaceMaterial(double splitFactor)
Constructor.
- Parameters
splitFactor – is the splitting ratio between pre/post update
-
inline ISurfaceMaterial(double splitFactor, Acts::MappingType mappingType)
Constructor.
- Parameters
splitFactor – is the splitting ratio between pre/post update
mappingType – is the type of surface mapping associated to the surface
-
virtual ~ISurfaceMaterial() = default
Destructor.
Update pre factor.
- Parameters
pDir – is the navigation direction through the surface
mStage – is the material update directive (onapproach, full, onleave)
-
inline MappingType mappingType() const
Return the type of surface material mapping.
-
virtual const MaterialSlab &materialSlab(const Vector2 &lp) const = 0
Return method for full material description of the Surface.
from local coordinate on the surface
- Parameters
lp – is the local position used for the (eventual) lookup
- Returns
const MaterialSlab
-
virtual const MaterialSlab &materialSlab(const Vector3 &gp) const = 0
Return method for full material description of the Surface.
from the global coordinates
- Parameters
gp – is the global position used for the (eventual) lookup
- Returns
const MaterialSlab
-
virtual const MaterialSlab &materialSlab(size_t bin0, size_t bin1) const = 0
Direct access via bins to the MaterialSlab.
- Parameters
bin0 – is the material bin in dimension 0
bin1 – is the material bin in dimension 1
Return method for fully scaled material description of the Surface.
from local coordinate on the surface
- Parameters
lp – is the local position used for the (eventual) lookup
pDir – is the navigation direction through the surface
mStage – is the material update directive (onapproach, full, onleave)
- Returns
MaterialSlab
Return method for full material description of the Surface.
from the global coordinates
- Parameters
gp – is the global position used for the (eventual) lookup
pDir – is the navigation direction through the surface
mStage – is the material update directive (onapproach, full, onleave)
- Returns
MaterialSlab
-
virtual ISurfaceMaterial &operator*=(double scale) = 0
Scale operator.
- Parameters
scale – is the scale factor applied
-
virtual std::ostream &toStream(std::ostream &sl) const = 0
Output Method for std::ostream, to be overloaded by child classes.
Friends
-
inline friend std::ostream &operator<<(std::ostream &out, const ISurfaceMaterial &sm)
output stream operator
Prints information about this object to the output stream using the virtual ISurfaceMaterial::toStream method
- Returns
modified output stream object
-
ISurfaceMaterial() = default
-
template<typename vfitter_t, typename sfinder_t>
class IterativeVertexFinder - #include <Acts/Vertexing/IterativeVertexFinder.hpp>
Implements an iterative vertex finder.
Brief description of the algorithm implemented: Iterative vertex finder which iteratively finds and fits vertices:
A list of seed tracks (
seedTracks
, which is the same as the input track list to the finder at the very first iteration) is used to retrieve a single vertex seed using the ZScanVertexFinder.All tracks compatible with the current vertex seed are kept and used for fitting the single vertex. 3.1 If the vertex is a ‘good’ vertex (i.e. meets requirements) and no track reassignment after first fit is required, go to step 4. If vertex is not a good vertex, remove all tracks in perigeesToFit from seedTracks. 3.2 If vertex meets requirements and track reassignment after first fit is required, iterate over all previously found vertices (“old vertex”) and over all their tracksAtVertex. Compare compatibility of each track with old vertex and current vertex. If track is more compatible with current vertex, remove track from old vertex, put track back to perigeesToFit and refit current vertex with additional track.
If good vertex,
removeUsedCompatibleTracks
method is called, which removes all used tracks that are compatible with the fitted vertex fromperigeesToFit
andseedTracks
. It also removes outliers tracks from tracksAtVertex if not compatible.Add vertex to vertexCollection
Repeat until no seedTracks are left or max. number of vertices found
- Template Parameters
vfitter_t – Vertex fitter type
sfinder_t – Seed finder type
Public Types
-
using InputTrack_t = typename vfitter_t::InputTrack_t
-
using IPEstimator = ImpactPointEstimator<InputTrack_t, Propagator_t>
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline IterativeVertexFinder(Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("IterativeVertexFinder", Logging::INFO)) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
logger – The logging instance
-
inline IterativeVertexFinder(Config &cfg, std::function<BoundTrackParameters(InputTrack_t)> func, std::unique_ptr<const Logger> logger = getDefaultLogger("IterativeVertexFinder", Logging::INFO))
Constructor for user-defined InputTrack_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
logger – The logging instance
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &trackVector, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Finds vertices corresponding to input trackVector.
- Parameters
trackVector – Input tracks
vertexingOptions – Vertexing options
state – State for fulfilling interfaces
- Returns
Collection of vertices found by finder
-
struct Config
- #include <Acts/Vertexing/IterativeVertexFinder.hpp>
Configuration struct.
Public Functions
-
inline Config(const vfitter_t &fitter, const Linearizer_t &lin, sfinder_t sfinder, const IPEstimator &est)
Config constructor.
- Parameters
fitter – Vertex fitter
lin – Track linearizer
sfinder – The seed finder
est – ImpactPointEstimator
Public Members
-
bool createSplitVertices = false
-
double cutOffTrackWeight = 0.01
-
bool doMaxTracksCut = false
-
IPEstimator ipEst
ImpactPointEstimator.
-
Linearizer_t linearizer
Linearized track factory.
-
double maximumChi2cutForSeeding = 36.
-
int maxTracks = 5000
-
int maxVertices = 50
-
bool reassignTracksAfterFirstFit = false
-
sfinder_t seedFinder
Vertex seed finder.
-
double significanceCutSeeding = 10
-
int splitVerticesTrkInvFraction = 2
-
bool useBeamConstraint = false
Vertex finder configuration variables.
-
vfitter_t vertexFitter
Vertex fitter.
-
inline Config(const vfitter_t &fitter, const Linearizer_t &lin, sfinder_t sfinder, const IPEstimator &est)
-
struct State
- #include <Acts/Vertexing/IterativeVertexFinder.hpp>
State struct.
Public Functions
-
inline State(const MagneticFieldProvider &field, const Acts::MagneticFieldContext &magContext)
Public Members
-
vfitter_t::State fitterState
The fitter state.
-
IPEstimator::State ipState
The IP estimator state.
-
Linearizer_t::State linearizerState
The inearizer state.
-
inline State(const MagneticFieldProvider &field, const Acts::MagneticFieldContext &magContext)
-
class ITGeoDetectorElementSplitter
- #include <Acts/Plugins/TGeo/ITGeoDetectorElementSplitter.hpp>
ITGeoElementSplitter.
Interface class that allows to define splitting of TGeoElements into sub-elements
Subclassed by Acts::TGeoCylinderDiscSplitter
Public Functions
-
virtual ~ITGeoDetectorElementSplitter() = default
Take a geometry context and TGeoElement and split it into sub elements.
Note
If no split is performed the unsplit detector element is returned
- Parameters
gctx – is a geometry context object
tgde – is a TGeoDetectorElement that is eventually split
- Returns
a vector of TGeoDetectorElement objects
-
virtual ~ITGeoDetectorElementSplitter() = default
-
class ITGeoIdentifierProvider
- #include <Acts/Plugins/TGeo/ITGeoIdentifierProvider.hpp>
ITGeoIdentierProvider.
Interface class that provides an Indentifier from a TGeoNode
Public Functions
-
virtual Identifier identify(const GeometryContext &gctx, const TGeoNode &tgnode) const = 0
Take a geometry context and a TGeoNode and provide an identifier.
- Parameters
gctx – is a geometry context object
tgnode – is a TGeoNode that is translated
-
virtual Identifier identify(const GeometryContext &gctx, const TGeoNode &tgnode) const = 0
-
class ITrackingGeometryBuilder
- #include <Acts/Geometry/ITrackingGeometryBuilder.hpp>
Interface class for the TrackingGeometry building, this is used by the TrackingGeometrySvc to build the geoemtry.
The TrackingGeometry is written to the detector store and thus not created as a std::shared_ptr.
The TrackingGeometry is returned as a non-const object in order to recreate from conditions callback if necessary.
Subclassed by Acts::TrackingGeometryBuilder
Public Functions
-
virtual ~ITrackingGeometryBuilder() = default
Virtual destructor.
-
virtual std::unique_ptr<const TrackingGeometry> trackingGeometry(const GeometryContext &gctx) const = 0
TrackingGeometry Interface methode.
- Parameters
gctx – ist the geometry context for witch the geometry is built
- Returns
unique pointer to a newly created TrackingGeometry
-
virtual ~ITrackingGeometryBuilder() = default
-
class ITrackingVolumeArrayCreator
- #include <Acts/Geometry/ITrackingVolumeArrayCreator.hpp>
Interface class ITrackingVolumeArrayCreators It inherits from IAlgTool.
It is designed to centralize the code to create Arrays of Tracking Volumes for both:
confinement in another TrackingVolume
navigation and glueing
Arrays for glueing and confinement are often the same, therefore the newly created TrackingVolumeArray is done by a shared_ptr
Subclassed by Acts::TrackingVolumeArrayCreator
Public Functions
-
virtual ~ITrackingVolumeArrayCreator() = default
Virtual destructor.
-
virtual std::shared_ptr<const TrackingVolumeArray> trackingVolumeArray(const GeometryContext &gctx, const TrackingVolumeVector &vols, BinningValue bVal) const = 0
TrackingVolumeArrayCreator interface method - creates array depending on the binning type.
- Parameters
gctx – [in] the geometry context for this building
vols – are the TrackingVolumes ordered in a tracker
bVal – is the binning value for the volume binning
- Returns
sahred pointer to a new TrackingVolumeArray
-
class ITrackingVolumeBuilder
- #include <Acts/Geometry/ITrackingVolumeBuilder.hpp>
Interface class ITrackingVolumeBuilders.
this returns the sub-detector tracking volume that is wrapped by the next outer one in the TrackingGeometry building process
If an innerVolume is given, this is wrapped If a VolumeBounds object is given this defines the maximum extent.
Subclassed by Acts::CuboidVolumeBuilder, Acts::CylinderVolumeBuilder
Public Functions
-
virtual ~ITrackingVolumeBuilder() = default
Virtual destructor.
-
virtual MutableTrackingVolumePtr trackingVolume(const GeometryContext &gctx, TrackingVolumePtr oppositeVolume = nullptr, VolumeBoundsPtr outsideBounds = nullptr) const = 0
ITrackingVolumeBuilder interface method.
- Parameters
gctx – is the geometry context for witch the volume is built
oppositeVolume – is an (optional) volume to be wrapped
outsideBounds – is an (optional) outside confinement
- Returns
shared pointer to a newly created TrackingVolume
-
virtual ~ITrackingVolumeBuilder() = default
-
class ITrackingVolumeHelper
- #include <Acts/Geometry/ITrackingVolumeHelper.hpp>
Interface class ITrackingVolumeHelper tools, it inherits from IAlgTool.
The ITrackingVolumeHelper is a tool to pack a set of layers into a volume, or - to wrap several volumes into a container volume.
TrackingVolumes only exist as std::shared_ptr
Subclassed by Acts::CylinderVolumeHelper
Public Functions
-
virtual ~ITrackingVolumeHelper() = default
Virtual destructor.
-
virtual MutableTrackingVolumePtr createContainerTrackingVolume(const GeometryContext &gctx, const TrackingVolumeVector &volumes) const = 0
Create a one level higher TrackingVolue.
- Parameters
gctx – is the geometry context for witch the volume is built
volumes – the volumes to be contained
- Returns
shared pointer to a new TrackingVolume
Create a gap volume from dimensions and.
- Parameters
gctx – is the geometry context for witch the volume is built
mtvVector – Vector of confined TrackingVolumes
volumeMaterial – material properties for this TrackingVolume
loc0Min, loc0Max, loc1Min, loc1Max – : local position in space, this TrackingVolume is restricted to Translation only
materialLayers – number of material layers (aequidistant binning)
cylinder – type of layers
volumeName – volume name to be given
- Returns
shared pointer to a new TrackingVolume
Create a gap volume from dimensions and.
- Parameters
gctx – is the geometry context for witch the volume is built
mtvVector – Vector of confined TrackingVolumes
volumeMaterial – material properties for this TrackingVolume
loc0Min, loc0Max, loc1Min, loc1Max – local position in space,
layerPositions – custom layer positions
cylinder – type of layers
volumeName – : volume name to be given
btype – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
Create a TrackingVolume* from a set of layers and (optional) parameters.
- Parameters
gctx – is the geometry context for witch the volume is built
layers – vector of static layers confined by the TrackingVolume if no bounds or HepTransform is given, they define the size together with the volume enevlope parameters
volumeMaterial – material properties for this TrackingVolume
volumeBounds – confinement of this TrackingVolume
mtvVector – (optional) Vector of confined TrackingVolumes
transform – (optional) placement of this TrackingVolume
volumeName – volume name to be given
btype – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
Create a TrackingVolume* from a set of layers and (optional) parameters.
- Parameters
gctx – is the geometry context for witch the volume is built
layers – vector of static layers confined by the TrackingVolume if no bounds or HepTransform is given, they define the size together with the volume enevlope parameters
volumeMaterial – material properties for this TrackingVolume
mtvVector – Vector of confined TrackingVolumes
loc0Min, loc0Max, loc1Min, loc1Max – : local position in space, this TrackingVolume is restricted to Translation only
volumeName – volume name to be given
btype – (optional) BinningType - arbitrary(default) or equidistant
- Returns
shared pointer to a new TrackingVolume
-
virtual ~ITrackingVolumeHelper() = default
-
class IVisualization3D
- #include <Acts/Visualization/IVisualization3D.hpp>
Partially abstract base class which provides an interface to visualization helper classes.
It provides a number of methods that all the helpers need to conform to.
Subclassed by Acts::ObjVisualization3D< T >, Acts::PlyVisualization3D< T >
Public Types
-
using FaceType = std::vector<size_t>
Public Functions
-
virtual void clear() = 0
Remove all contents of this helper.
-
virtual void face(const std::vector<Vector3> &vtxs, ColorRGB color = {120, 120, 120}) = 0
Draw a face that connects a list of vertices.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the face
color – The color of the face
-
virtual void faces(const std::vector<Vector3> &vtxs, const std::vector<FaceType> &faces, ColorRGB color = {120, 120, 120}) = 0
Draw a faces that connects a list of vertices - expert only.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the faceS
faces – The face presectiotions (i.e. connecting vertices)
color – The color of the face
-
virtual void line(const Vector3 &a, const Vector3 &b, ColorRGB color = {120, 120, 120}) = 0
Draw a line from a vertex to another.
- Parameters
a – The start vertex
b – The end vertex
color – The color of the line
-
virtual void vertex(const Vector3 &vtx, ColorRGB color = {120, 120, 120}) = 0
Draw a vertex at a given location and a color.
- Parameters
vtx – The vertex position
color – The color
-
virtual void write(std::ostream &os) const = 0
Write the content of the helper to an outstream.
- Parameters
os – The output stream for file
-
virtual void write(const std::string &path) const = 0
Write the content of the helper to an outstream.
Note
wil change to std::filesystem::path once gcc9 is standard
- Parameters
path – is the file system path for writing the file
-
using FaceType = std::vector<size_t>
-
class IVolumeMaterial
- #include <Acts/Material/IVolumeMaterial.hpp>
Material associated with a Volume (homogenous, binned, interpolated)
Virtual base class of volume material description.
Subclassed by Acts::HomogeneousVolumeMaterial, Acts::InterpolatedMaterialMap< Mapper_t >, Acts::ProtoVolumeMaterial
Public Functions
-
virtual ~IVolumeMaterial() = default
Virtual Destructor.
-
virtual const Material material(const Vector3 &position) const = 0
Access to actual material.
- Parameters
position – is the request position for the material call
-
virtual std::ostream &toStream(std::ostream &sl) const = 0
Output Method for std::ostream, to be overloaded by child classes.
Friends
-
inline friend std::ostream &operator<<(std::ostream &out, const IVolumeMaterial &vm)
output stream operator
Prints information about this object to the output stream using the virtual IVolumeeMaterial::toStream method
- Returns
modified output stream object
-
virtual ~IVolumeMaterial() = default
-
struct jsonKey
- #include <Acts/Plugins/Json/GeometryJsonKeys.hpp>
store in a single place the different key used for the material mapping
Public Members
-
std::string binkey = "binUtility"
The bin key.
-
std::string datakey = "data"
The data key.
-
std::string mapkey = "mapMaterial"
The mapping key, add surface to mapping procedure if true.
-
std::string maptype = "mappingType"
The mapping type key, used to select the type od material mapping for the surface.
-
std::string materialkey = "material"
The material key.
-
std::string namekey = "NAME"
The name identification.
-
std::string transfokeys = "transformation"
The local to global transformation key.
-
std::string typekey = "type"
The type key -> proto, else.
-
std::string binkey = "binUtility"
-
class JsonMaterialDecorator : public Acts::IMaterialDecorator
- #include <Acts/Plugins/Json/JsonMaterialDecorator.hpp>
Material decorator from Json format.
This reads in material maps for surfaces and volumes from a json file
Public Types
-
using SurfaceMaterialMap = std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>
-
using VolumeMaterialMap = std::map<GeometryIdentifier, std::shared_ptr<const IVolumeMaterial>>
Public Functions
-
inline JsonMaterialDecorator(const MaterialMapJsonConverter::Config &rConfig, const std::string &jFileName, Acts::Logging::Level level, bool clearSurfaceMaterial = true, bool clearVolumeMaterial = true)
-
inline virtual void decorate(Surface &surface) const final
Decorate a surface.
- Parameters
surface – the non-cost surface that is decorated
-
inline virtual void decorate(TrackingVolume &volume) const final
Decorate a TrackingVolume.
- Parameters
volume – the non-cost volume that is decorated
-
using SurfaceMaterialMap = std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>
-
template<typename propagator_t, typename traj_t>
class KalmanFitter - #include <Acts/TrackFitting/KalmanFitter.hpp>
Kalman fitter implementation.
The Kalman filter contains an Actor and a Sequencer sub-class. The Sequencer has to be part of the Navigator of the Propagator in order to initialize and provide the measurement surfaces.
The Actor is part of the Propagation call and does the Kalman update and eventually the smoothing. Updater, Smoother and Calibrator are given to the Actor for further use:
The Updater is the implemented kalman updater formalism, it runs via a visitor pattern through the measurements.
The Smoother is called at the end of the filtering by the Actor.
Measurements are not required to be ordered for the KalmanFilter, measurement ordering needs to be figured out by the navigation of the propagator.
The void components are provided mainly for unit testing.
- Template Parameters
propagator_t – Type of the propagation class
Public Functions
-
inline KalmanFitter(propagator_t pPropagator)
Fit implementation of the foward filter, calls the the filter and smoother/reversed filter.
Note
The input measurements are given in the form of
SourceLink
s. It’s the calibrators job to turn them into calibrated measurements used in the fit.- Template Parameters
source_link_iterator_t – Iterator type used to pass source links
start_parameters_t – Type of the initial parameters
parameters_t – Type of parameters used for local parameters
- Parameters
it – Begin iterator for the fittable uncalibrated measurements
end – End iterator for the fittable uncalibrated measurements
sParameters – The initial track parameters
kfOptions – KalmanOptions steering the fit
trajectory – Input trajectory storage to append into
- Returns
the output as an output track
Fit implementation of the foward filter, calls the the filter and smoother/reversed filter.
Note
The input measurements are given in the form of
SourceLinks
. It’scalibrator_t's
job to turn them into calibrated measurements used in the fit.- Template Parameters
source_link_iterator_t – Iterator type used to pass source links
start_parameters_t – Type of the initial parameters
parameters_t – Type of parameters used for local parameters
- Parameters
it – Begin iterator for the fittable uncalibrated measurements
end – End iterator for the fittable uncalibrated measurements
sParameters – The initial track parameters
kfOptions – KalmanOptions steering the fit
sSequence – surface sequence used to initialize a DirectNavigator
trajectory – Optional input track state container
- Returns
the output as an output track
-
template<typename traj_t>
struct KalmanFitterExtensions - #include <Acts/TrackFitting/KalmanFitter.hpp>
Extension struct which holeds delegates to customize the KF behavior.
Public Types
-
using Calibrator = Delegate<void(const GeometryContext&, TrackStateProxy)>
-
using ConstTrackStateProxy = typename MultiTrajectory<traj_t>::ConstTrackStateProxy
-
using OutlierFinder = Delegate<bool(ConstTrackStateProxy)>
-
using Parameters = typename TrackStateProxy::Parameters
-
using ReverseFilteringLogic = Delegate<bool(ConstTrackStateProxy)>
-
using Smoother = Delegate<Result<void>(const GeometryContext&, MultiTrajectory<traj_t>&, size_t, LoggerWrapper)>
-
using TrackStateProxy = typename MultiTrajectory<traj_t>::TrackStateProxy
-
using Updater = Delegate<Result<void>(const GeometryContext&, TrackStateProxy, NavigationDirection, LoggerWrapper)>
Public Functions
-
inline KalmanFitterExtensions()
Default constructor which connects the default void components.
Public Members
-
Calibrator calibrator
The Calibrator is a dedicated calibration algorithm that allows to calibrate measurements using track information, this could be e.g.
sagging for wires, module deformations, etc.
-
OutlierFinder outlierFinder
Determines whether a measurement is supposed to be considered as an outlier.
-
ReverseFilteringLogic reverseFilteringLogic
Decides whether the smoothing stage uses linearized transport or full reverse propagation.
-
Smoother smoother
The smoother back-propagates measurement information along the track.
-
Updater updater
The updater incorporates measurement information into the track parameters.
-
using Calibrator = Delegate<void(const GeometryContext&, TrackStateProxy)>
-
template<typename traj_t>
struct KalmanFitterOptions - #include <Acts/TrackFitting/KalmanFitter.hpp>
Combined options for the Kalman fitter.
- Template Parameters
traj_t – The trajectory type
Public Functions
-
inline KalmanFitterOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, std::reference_wrapper<const CalibrationContext> cctx, KalmanFitterExtensions<traj_t> extensions_, LoggerWrapper logger_, const PropagatorPlainOptions &pOptions, const Surface *rSurface = nullptr, bool mScattering = true, bool eLoss = true, bool rFiltering = false, double rfScaling = 1.0, const FreeToBoundCorrection &freeToBoundCorrection_ = FreeToBoundCorrection(false))
PropagatorOptions with context.
- Parameters
gctx – The goemetry context for this fit
mctx – The magnetic context for this fit
cctx – The calibration context for this fit
extensions_ – The KF extensions
logger_ – The logger wrapper
pOptions – The plain propagator options
rSurface – The reference surface for the fit to be expressed at
mScattering – Whether to include multiple scattering
eLoss – Whether to include energy loss
rFiltering – Whether to run filtering in reversed direction as smoothing
rfScaling – Scale factor for the covariance matrix before the backward filtering
freeToBoundCorrection_ – Correction for non-linearity effect during transform from free to bound
-
KalmanFitterOptions() = delete
Contexts are required and the options must not be default-constructible.
Public Members
-
std::reference_wrapper<const CalibrationContext> calibrationContext
context object for the calibration
-
bool energyLoss = true
Whether to consider energy loss.
-
KalmanFitterExtensions<traj_t> extensions
-
FreeToBoundCorrection freeToBoundCorrection
Whether to include non-linear correction during global to local transformation.
-
std::reference_wrapper<const GeometryContext> geoContext
Context object for the geometry.
-
LoggerWrapper logger
Logger.
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
Context object for the magnetic field.
-
bool multipleScattering = true
Whether to consider multiple scattering.
-
PropagatorPlainOptions propagatorPlainOptions
The trivial propagator options.
-
const Surface *referenceSurface = nullptr
The reference Surface.
-
bool reversedFiltering = false
Whether to run filtering in reversed direction overwrite the ReverseFilteringLogic.
-
double reversedFilteringCovarianceScaling = 1.0
Factor by which the covariance of the input of the reversed filtering is scaled.
This is only used in the backwardfiltering (if reversedFiltering is true or if the ReverseFilteringLogic return true for the track of interest)
-
template<typename traj_t>
struct KalmanFitterResult - #include <Acts/TrackFitting/KalmanFitter.hpp>
Public Members
-
bool finished = false
-
std::optional<BoundTrackParameters> fittedParameters
-
std::shared_ptr<traj_t> fittedStates
-
size_t lastMeasurementIndex = SIZE_MAX
-
size_t lastTrackIndex = SIZE_MAX
-
size_t measurementHoles = 0
-
size_t measurementStates = 0
-
std::vector<const Surface*> missedActiveSurfaces
-
std::vector<const Surface*> passedAgainSurfaces
-
size_t processedStates = 0
-
bool reversed = false
-
bool smoothed = false
-
bool finished = false
-
template<std::size_t Dims, typename Type, typename Scalar = double, template<typename, std::size_t> typename Vector = std::array, std::size_t LeafSize = 4>
class KDTree - #include <Acts/Utilities/KDTree.hpp>
A general k-d tree with fast range search.
This is a generalized k-d tree, with a configurable number of dimension, scalar type, content type, index type, vector type, and leaf size. This class is purposefully generalized to support a wide range of use cases.
A k-d tree is, in essence, a k-dimensional binary search tree. Each interal node splits the content of the tree in half, with the pivot point being an orthogonal hyperplane in one of the k dimensions. This allows us to efficiently look up points within certain k-dimensional ranges.
This particular class is mostly a wrapper class around an underlying node class which does all the actual work.
Note
This type is completely immutable after construction.
- Template Parameters
Dims – The number of dimensions.
Type – The type of value contained in the tree.
Scalar – The scalar type used to construct position vectors.
Vector – The general vector type used to construct coordinates.
LeafSize – The maximum number of elements stored in a leaf node.
Public Types
-
using const_iterator_t = typename vector_t::const_iterator
-
using iterator_t = typename vector_t::iterator
The type of iterators in our vectors.
-
using pair_t = std::pair<coordinate_t, Type>
The type of coordinate-value pairs.
-
using range_t = RangeXD<Dims, Scalar, Vector>
The type describing a multi-dimensional orthogonal range.
-
using value_t = Type
The type of value contained in this k-d tree.
-
using vector_t = std::vector<pair_t>
The type of a vector of coordinate-value pairs.
Public Functions
-
KDTree() = delete
-
inline KDTree(vector_t &&d)
Construct a k-d tree from a vector of position-value pairs.
This constructor takes an r-value reference to a vector of position-value pairs and constructs a k-d tree from those pairs.
- Parameters
d – The vector of position-value pairs to construct the k-d tree from.
-
inline const_iterator_t begin(void) const
-
inline const_iterator_t end(void) const
-
inline std::vector<Type> rangeSearch(const range_t &r) const
Perform an orthogonal range search within the k-d tree.
A range search operation is one that takes a k-d tree and an orthogonal range, and returns all values associated with coordinates in the k-d tree that lie within the orthogonal range. k-d trees can do this operation quickly.
- Parameters
r – The range to search for.
- Returns
The vector of all values that lie within the given range.
-
inline void rangeSearch(const range_t &r, std::vector<Type> &v) const
Perform an in-place orthogonal range search within the k-d tree.
This range search module operates in place, writing its results to the given output vector.
- Parameters
r – The range to search for.
v – The vector to write the output to.
-
template<typename OutputIt>
inline void rangeSearchInserter(const range_t &r, OutputIt i) const Perform an orthogonal range search within the k-d tree, writing the resulting values to an output iterator.
This method allows the user more control in where the result is written to.
- Template Parameters
OutputIt – The type of the output iterator.
- Parameters
r – The range to search for.
i – The iterator to write the output to.
-
template<typename OutputIt>
inline void rangeSearchInserterWithKey(const range_t &r, OutputIt i) const Perform an orthogonal range search within the k-d tree, writing the resulting values to an output iterator, including the keys.
Performs the same operation as the keyless version, but includes the key in the output.
- Template Parameters
OutputIt – The type of the output iterator.
- Parameters
r – The range to search for.
i – The iterator to write the output to.
-
template<typename Result>
inline std::vector<Result> rangeSearchMap(const range_t &r, std::function<Result(const coordinate_t&, const Type&)> f) const Perform an orthogonal range search within the k-d tree, applying a mapping function to the values found.
In some cases, we may wish to transform the values in some way. This method allows the user to provide a mapping function which takes a set of coordinates and a value and transforms them to a new value, which is returned.
Note
Your compiler may not be able to deduce the result type automatically, in which case you will need to specify it manually.
- Template Parameters
Result – The return type of the map operation.
- Parameters
r – The range to search for.
f – The mapping function to apply to key-value pairs.
- Returns
A vector of elements matching the range after the application of the mapping function.
-
inline void rangeSearchMapDiscard(const range_t &r, std::function<void(const coordinate_t&, const Type&)> f) const
Perform an orthogonal range search within the k-d tree, applying a a void-returning function with side-effects to each key-value pair.
This is the most general version of range search in this class, and every other operation can be reduced to this operation as long as we allow arbitrary side-effects.
Functional programmers will know this method as mapM_.
- Parameters
r – The range to search for.
f – The mapping function to apply to key-value pairs.
-
template<typename Result, typename OutputIt>
inline void rangeSearchMapInserter(const range_t &r, std::function<Result(const coordinate_t&, const Type&)> f, OutputIt i) const Perform an orthogonal range search within the k-d tree, applying a mapping function to the values found, and inserting them into an inserter.
Performs the same operation as the interter-less version, but allows the user additional control over the insertion process.
Note
Your compiler may not be able to deduce the result type automatically, in which case you will need to specify it manually.
- Template Parameters
Result – The return type of the map operation.
OutputIt – The type of the output iterator.
- Parameters
r – The range to search for.
f – The mapping function to apply to key-value pairs.
i – The inserter to insert the results into.
-
inline std::vector<pair_t> rangeSearchWithKey(const range_t &r) const
Perform an orthogonal range search within the k-d tree, returning keys as well as values.
Performs the same logic as the keyless version, but includes a copy of the key with each element.
- Parameters
r – The range to search for.
- Returns
The vector of all key-value pairs that lie within the given range.
-
inline void rangeSearchWithKey(const range_t &r, std::vector<pair_t> &v) const
Perform an in-place orthogonal range search within the k-d tree, including keys in the result.
Performs the same operation as the keyless version, but includes the keys in the results.
- Parameters
r – The range to search for.
v – The vector to write the output to.
-
inline std::size_t size(void) const
Return the number of elements in the k-d tree.
We simply defer this method to the root node of the k-d tree.
- Returns
The number of elements in the k-d tree.
-
inline std::string toString(void) const
Return a string representing the structure of the k-d tree.
Used mostly for debugging purposes. You probably do not want to call this in actual code.
-
class Layer : public virtual Acts::GeometryObject
- #include <Acts/Geometry/Layer.hpp>
Base Class for a Detector Layer in the Tracking Geometry.
An actual implemented Detector Layer inheriting from this base class has to inherit from a specific type of Surface as well. In addition, a Layer can carry:
A SurfaceArray of Surfaces holding the actual detector elements or subSurfaces. A pointer to the TrackingVolume (can only be set by such) An active/passive code : 0 - activ 1 - passive [….] - other
The search type for compatible surfaces on a layer is [ the higher the number, the faster ]: ——— Layer internal ———————————————— -1 - provide all intersection tested without boundary check 0 - provide all intersection tested with boundary check 1 - provide overlap descriptor based without boundary check 2 - provide overlap descriptor based with boundary check
A layer can have substructure regarding:
m_ssRepresentingSurface -> always exists (1), can have material (2)
m_ssSensitiveSurfaces -> can or not exist (0,1), can have material (2)
m_ssApproachSurfaces -> can or not exist (0,1) cam have material (2)
Subclassed by Acts::ConeLayer, Acts::CylinderLayer, Acts::DiscLayer, Acts::NavigationLayer, Acts::PlaneLayer
Public Functions
-
Layer() = delete
Default Constructor - deleted.
-
Layer(const Layer&) = delete
Copy Constructor - deleted.
-
virtual ~Layer() = default
Destructor.
-
const ApproachDescriptor *approachDescriptor() const
Return method for the approach descriptor, can be nullptr.
-
ApproachDescriptor *approachDescriptor()
Non-const version of the approach descriptor.
Decompose Layer into (compatible) surfaces.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – Position parameter for searching
direction – Direction of the parameters for searching
options – The navigation options
- Returns
list of intersection of surfaces on the layer
-
virtual bool isOnLayer(const GeometryContext &gctx, const Vector3 &position, const BoundaryCheck &bcheck = true) const
geometrical isOnLayer() method
Note
using isOnSurface() with Layer specific tolerance
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the gobal position to be checked
bcheck – is the boundary check directive
- Returns
boolean that indicates success of the operation
-
LayerType layerType() const
return the LayerType
-
const Layer *nextLayer(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const
Fast navigation to next layer.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the start position for the search
direction – is the direction for the search
- Returns
the pointer to the next layer
-
Layer &operator=(const Layer &layer) = delete
Assignment operator - forbidden, layer assignment must not be ambiguous.
- Parameters
layer – is the source layer for assignment
-
const AbstractVolume *representingVolume() const
Return the abstract volume that represents the layer.
- Returns
the representing volume of the layer
-
template<typename options_t>
inline bool resolve(const options_t &options) const Accept layer according to the following collection directives.
- Template Parameters
options_t – Type of the options for navigation
- Returns
a boolean whether the layer is accepted for processing
-
virtual bool resolve(bool resolveSensitive, bool resolveMaterial, bool resolvePassive) const
Accept layer according to the following collection directives.
- Parameters
resolveSensitive – is the prescription to find the sensitive surfaces
resolveMaterial – is the precription to find material surfaces
resolvePassive – is the prescription to find all passive surfaces
- Returns
a boolean whether the layer is accepted for processing
-
const SurfaceArray *surfaceArray() const
Return the entire SurfaceArray, returns a nullptr if no SurfaceArray.
-
SurfaceArray *surfaceArray()
Non-const version.
Surface seen on approach for layers without sub structure, this is the surfaceRepresentation for layers with sub structure, this is the approachSurface.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – Position for searching
direction – Direction for searching
options – The navigation options
- Returns
the Surface intersection of the approach surface
-
virtual const Surface &surfaceRepresentation() const = 0
Transforms the layer into a Surface representation for extrapolation.
Note
the layer can be hosting many surfaces, but this is the global one to which one can extrapolate
-
virtual Surface &surfaceRepresentation() = 0
-
double thickness() const
Return the Thickness of the Layer this is by definition along the normal vector of the surfaceRepresentation.
-
const TrackingVolume *trackingVolume() const
Get the confining TrackingVolume.
- Returns
the pointer to the enclosing volume
-
class LayerArrayCreator : public Acts::ILayerArrayCreator
- #include <Acts/Geometry/LayerArrayCreator.hpp>
The LayerArrayCreator is a simple Tool that helps to construct LayerArrays from std::vector of Acts::CylinderLayer, Acts::DiscLayer, Acts::PlaneLayer.
It fills the gaps automatically with Acts::NavigationLayer to be processed easily in the Navigation of the Extrapolation process.
Public Functions
-
inline LayerArrayCreator(const Config&, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerArrayCreator", Logging::INFO))
Constructor.
- Parameters
logger – logging instance
-
~LayerArrayCreator() override = default
Destructor.
-
virtual std::unique_ptr<const LayerArray> layerArray(const GeometryContext &gctx, const LayerVector &layersInput, double min, double max, BinningType bType = arbitrary, BinningValue bValue = binX) const override
LayerArrayCreator interface method.
- Parameters
gctx – ist the geometry context for witch the array is built
layersInput – are the layers to be moved into an array
min – is the minimum value for binning
max – is the maximum value for binning
bType – is the binning type
bValue – is the value in which the binning should be done
- Returns
unique pointer to a newly created LayerArray
-
inline void setLogger(std::unique_ptr<const Logger> logger)
set logging instance
-
struct Config
- #include <Acts/Geometry/LayerArrayCreator.hpp>
This struct stores the configuration of the tracking geometry.
-
inline LayerArrayCreator(const Config&, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerArrayCreator", Logging::INFO))
-
class LayerCreator
- #include <Acts/Geometry/LayerCreator.hpp>
The LayerCreator is able to build cylinde,r disc layers or plane layers from detector elements.
Public Functions
-
LayerCreator(const Config &lcConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerCreator", Logging::INFO))
Constructor.
- Parameters
lcConfig – is the configuration object
logger – logging instance
-
~LayerCreator() = default
Destructor.
-
void associateSurfacesToLayer(Layer &layer) const
returning a cylindrical layer
- Parameters
gctx – ist the geometry context with which the geometry is built
surfaces – is the vector of pointers to sensitive surfaces represented by this layer
binsPhi – is number of bins the sensitive surfaces are ordered in phi
binsZ – is number of bins the sensitive surfaces are ordered in Z
_protoLayer – (optional) proto layer specifying the dimensions and envelopes
transform – is the (optional) transform of the layer
ad – possibility to hand over a specific ApproachDescriptor, which is needed for material mapping. Otherwise the default ApproachDescriptor will be taken used for this layer
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
shared pointer to a newly created layer
returning a cylindrical layer
- Parameters
gctx – ist the geometry context with which the geometry is built
surfaces – is the vector of pointers to sensitive surfaces represented by this layer
bTypePhi – binning type in phi (equidistant/arbitrary)
bTypeZ – binning type in z (equidistant/arbitrary)
_protoLayer – (optional) proto layer specifying the dimensions and envelopes
transform – is the (optional) transform of the layer
ad – possibility to hand over a specific ApproachDescriptor, which is needed for material mapping. Otherwise the default ApproachDescriptor will be taken used for this layer
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
shared pointer to a newly created layer
returning a disc layer
- Parameters
gctx – ist the geometry context with which the geometry is built
surfaces – is the vector of pointers to sensitive surfaces represented by this layer
binsR – is number of bins the sensitive surfaces are ordered in R
binsPhi – is number of bins the sensitive surfaces are ordered in Phi
transform – is the (optional) transform of the layer
_protoLayer – (optional) proto layer specifying the dimensions and envelopes
ad – possibility to hand over a specific ApproachDescriptor, which is needed for material mapping. Otherwise the default ApproachDescriptor will be taken used for this layer
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
shared pointer to a newly created layer
returning a disc layer
- Parameters
gctx – ist the geometry context with which the geometry is built
surfaces – is the vector of pointers to sensitive surfaces represented by this layer
bTypeR – binning type in r (equidistant/arbitrary)
bTypePhi – binning type in phi (equidistant/arbitrary)
transform – is the (optional) transform of the layer
_protoLayer – (optional) proto layer specifying the dimensions and envelopes
ad – possibility to hand over a specific ApproachDescriptor, which is needed for material mapping. Otherwise the default ApproachDescriptor will be taken used for this layer
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
shared pointer to a newly created layer
-
inline Config getConfiguration() const
Access th configuration object.
returning a plane layer
- Parameters
gctx – ist the geometry context with which the geometry is built
surfaces – [in] is the vector of pointers to sensitive surfaces represented by this layer
bins1 – [in] is the number of bins in the orthogonal direction to
bValue
bins2 – [in] is the number of bins in the orthogonal direction to
bValue
bValue – [in] Direction of the aligned surfaces
transform – [in] is the (optional) transform of the layer
_protoLayer – [in] (optional) proto layer specifying the dimensions and envelopes
ad – [in] possibility to hand over a specific ApproachDescriptor, which is needed for material mapping. Otherwise the default ApproachDescriptor will be taken used for this layer
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
shared pointer to a newly created layer
-
void setConfiguration(const Config &lcConfig)
Set the configuration object.
- Parameters
lcConfig – is the configuration struct
-
void setLogger(std::unique_ptr<const Logger> newLogger)
set logging instance
- Parameters
newLogger – the logger instance
-
struct Config
- #include <Acts/Geometry/LayerCreator.hpp>
Configuration for the LayerCreator This is the nexted configuration struct for the LayerCreator class.
Public Functions
-
Config() = default
standard constructor
Public Members
-
double cylinderPhiTolerance = {0.1}
cylinder module phi tolerance : it counts at same phi, if …
-
double cylinderZtolerance = {10.}
cylinder module z tolerance : it counts at same z, if …
-
std::shared_ptr<const SurfaceArrayCreator> surfaceArrayCreator = nullptr
surface array helper
-
Config() = default
-
LayerCreator(const Config &lcConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerCreator", Logging::INFO))
-
struct LinCircle
- #include <Acts/Seeding/SeedFinderUtils.hpp>
A partial description of a circle in u-v space.
Public Members
-
float cotTheta
-
float Er
-
float iDeltaR
-
float r
-
float U
-
float V
-
float x
-
float y
-
float z
-
float Zo
-
float cotTheta
-
class LinearizedTrack
- #include <Acts/Vertexing/LinearizedTrack.hpp>
Class for linear expansion of track parameters in vicinity of vertex.
The measurement equation is linearized in the following way:
F_k= D_k (x_k - x_0k) + E_k (p_k - p_0k) + F^0_k
where F_k are the parameters at perigee nearest to the linearization point, x_k is the position of the vertex, p_k the track momentum at the vertex, and F^0_k is the constant term of expansion. D_k and E_k are matrices of derivatives, denoted hereafter as “positionJacobian” and “momentumJacobian” respectively.
Public Functions
-
LinearizedTrack() = default
-
inline LinearizedTrack(const BoundVector ¶msAtPCA, const BoundSymMatrix &parCovarianceAtPCA, const BoundSymMatrix &parWeightAtPCA, const Vector4 &linPoint, const ActsMatrix<eBoundSize, 4> &posJacobian, const ActsMatrix<eBoundSize, 3> &momJacobian, const Vector4 &position, const Vector3 &momentum, const BoundVector &constTerm)
Constructor taking perigee parameters and covariance matrix of track propagated to closest approach (PCA) of linearization point, position and momentum Jacobian and const term.
- Parameters
paramsAtPCA – Parameters at point of closest approach
parCovarianceAtPCA – Parameter covariance matrix at point of closest approach
parWeightAtPCA – The weight at the point of closest approach
linPoint – Linearization point
posJacobian – Position jacobian
momJacobian – Momentum jacobian
position – Position at point of closest approach
momentum – Momentum at point of closest approach
constTerm – Constant term in taylor expansion
Public Members
-
BoundVector constantTerm = {BoundVector::Zero()}
-
BoundSymMatrix covarianceAtPCA = {BoundSymMatrix::Zero()}
-
ActsMatrix<eBoundSize, 3> momentumJacobian = {ActsMatrix<eBoundSize, 3>::Zero()}
-
BoundVector parametersAtPCA = {BoundVector::Zero()}
-
ActsMatrix<eBoundSize, 4> positionJacobian = {ActsMatrix<eBoundSize, 4>::Zero()}
-
BoundSymMatrix weightAtPCA = {BoundSymMatrix::Zero()}
-
LinearizedTrack() = default
-
class LineBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/LineBounds.hpp>
Bounds for a LineSurface.
Public Types
-
enum BoundValues
Values:
-
enumerator eR
-
enumerator eHalfLengthZ
-
enumerator eSize
-
enumerator eR
Public Functions
-
LineBounds() = delete
-
inline LineBounds(double r, double halfZ) noexcept(false)
Constructor.
- Parameters
r – is the radius of the cylinder, default = 0.
halfZ – is the half length in z, defualt = 0.
-
inline LineBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array.
- Parameters
values – The parameter values
-
~LineBounds() override = default
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostream to be dumped into
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
enum BoundValues
-
class LineSurface : public Acts::Surface
- #include <Acts/Surfaces/LineSurface.hpp>
Base class for a linear surfaces in the TrackingGeometry to describe dirft tube, straw like detectors or the Perigee It inherits from Surface.
Note
It leaves the type() method virtual, so it can not be instantiated
Subclassed by Acts::PerigeeSurface, Acts::StrawSurface
Public Functions
-
LineSurface() = delete
-
~LineSurface() override = default
-
virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const final
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. the alignment parameters
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const final
The binning position is the position calcualted for a certain binning type.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the binning type to be used
- Returns
position that can beused for this binning
-
virtual const SurfaceBounds &bounds() const final
This method returns the bounds of the Surface by reference */.
-
virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const BoundVector &boundParams) const final
Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.
- Parameters
gctx – The current geometry context object, e.g. alignment
boundParams – is the bound parameters vector
- Returns
Jacobian from local to global
-
virtual FreeToPathMatrix freeToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const final
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
free parameters
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. free parameters
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const final
Specified for LineSurface: global to local method without dynamic memory allocation.
This method is the true global->local transformation.
makes use of globalToLocal and indicates the sign of the Acts::eBoundLoc0 by the given momentum
The calculation of the sign of the radius (or \( d_0 \)
) can be done as follows:
May
\( \vec d = \vec m - \vec c \) denote the difference between the center of the line and the global position of the measurement/predicted state, then \( \vec d \) lies within the so called measurement plane. The measurement plane is determined by the two orthogonal vectors \( \vec{measY}= \vec{Acts::eBoundLoc1} \) and \( \vec{measX} = \vec{measY} \times \frac{\vec{p}}{|\vec{p}|} \).The sign of the radius ( \( d_{0} \) ) is then defined by the projection of \( \vec{d} \) onto \( \vec{measX} \):\( sign = -sign(\vec{d} \cdot \vec{measX}) \)
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
momentum – global 3D momentum representation (optionally ignored)
tolerance – (unused)
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck = false) const final
Straight line intersection schema.
mathematical motivation: Given two lines in parameteric form:
\( \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} \)
\( \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} \) the vector between any two points on the two lines is given by:
\( \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot \vec e_{b} - \lambda \cdot \vec e_{a} \)
,
when
\( \vec m_{ab} = \vec m_{b} - \vec m_{a} \).\( \vec s(u, \mu_0) \) denotes the vector between the two closest points \( \vec l_{a,0} = l_{a}(u) \) and \( \vec l_{b,0} = l_{b}(\mu_0) \) and is perpendicular to both, \( \vec e_{a} \) and \( \vec e_{b} \).
This results in a system of two linear equations:
(i) \( 0 = \vec s(u, \mu_0) \cdot \vec e_a = \vec m_ab \cdot \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - u \)
(ii) \( 0 = \vec s(u, \mu_0) \cdot \vec e_b = \vec m_ab \cdot \vec e_b + \mu_0 - u \vec e_b \cdot \vec e_a \)
Solving (i), (ii) for \( u \) and \( \mu_0 \) yields:
\( u = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)
\( \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)
Note
exptected to be normalized
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The global position as a starting point
direction – The global direction at the starting point
bcheck – The boundary check directive for the estimate
- Returns
is the intersection object
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const final
Local to global transformation for line surfaces the momentum is used in order to interpret the drift radius.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position to be transformed
momentum – is the global momentum (used to sign the closest approach)
- Returns
global position by value
-
virtual std::string name() const override
Return properly formatted class name for screen output */.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final
Normal vector return.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position is ignored
- Returns
a Vector3 by value
-
LineSurface &operator=(const LineSurface &other)
Assignment operator.
- Parameters
other – is the source surface dor copying
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum) const override
the pathCorrection for derived classes with thickness is by definition 1 for LineSurfaces
Note
input parameters are ignored
Note
there’s no material associated to the line surface
-
virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum) const final
Return the measurement frame - this is needed for alignment, in particular.
for StraightLine and Perigee Surface
the default implementation is the RotationMatrix3 of the transform
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position where the measurement frame is constructed
momentum – is the momentum used for the measurement frame construction
- Returns
is a rotation matrix that indicates the measurement frame
-
LineSurface() = delete
-
class Logger
- #include <Acts/Utilities/Logger.hpp>
class for printing debug output
This class provides the user interface for printing debug messages with different levels of severity.
Public Functions
-
inline Logger(std::unique_ptr<Logging::OutputPrintPolicy> pPrint, std::unique_ptr<Logging::OutputFilterPolicy> pFilter)
construct from output print and filter policy
- Parameters
pPrint – [in] policy for printing debug messages
pFilter – [in] policy for filtering debug messages
-
inline Logger(std::unique_ptr<Logging::OutputPrintPolicy> pPrint, std::unique_ptr<Logging::OutputFilterPolicy> pFilter)
-
class LoggerWrapper
- #include <Acts/Utilities/Logger.hpp>
Class that contains (but doesn’t own) a logger instance.
Is callable so can be used with the logging macros.
Public Functions
-
LoggerWrapper() = delete
-
explicit LoggerWrapper(const Logger &logger)
Constructor ensuring a logger instance is given.
- Parameters
logger –
-
inline bool doPrint(const Logging::Level &lvl) const
Directly expose whether the contained logger will print at a level.
- Parameters
lvl – The level to check
- Returns
Whether to print at this level or not.
-
void log(const Logging::Level &lvl, const std::string &input) const
Add a logging message at a given level.
- Parameters
lvl – The level to print at
input – text of debug message
-
inline const Logger &operator()() const
Call operator that returns the contained logger instance.
Enables using the logging macros
ACTS_*
when an instance of this class is assigned to a local variablelogger
.- Returns
Reference to the logger instance.
-
LoggerWrapper() = delete
-
class MagneticFieldProvider
- #include <Acts/MagneticField/MagneticFieldProvider.hpp>
Base class for all magnetic field providers.
Subclassed by Acts::ConstantBField, Acts::InterpolatedMagneticField, Acts::NullBField, Acts::SolenoidBField
Public Types
-
using Cache = detail::SmallObjectCache
Opaque cache type that can store arbitrary implementation specific cache data.
Examples are an interpolation cell, or an experiment specific conditions data handle.
Public Functions
-
inline virtual ~MagneticFieldProvider()
-
virtual Result<Vector3> getField(const Vector3 &position, Cache &cache) const = 0
Retrieve magnetic field value at a given location.
Requires a cache object created through makeCache().
- Parameters
position – [in] global 3D position for the lookup
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector at given position
-
virtual Result<Vector3> getFieldGradient(const Vector3 &position, ActsMatrix<3, 3> &derivative, Cache &cache) const = 0
Retrieve magnetic field value its its gradient.
Requires a cache object created through makeCache().
- Parameters
position – [in] global 3D position
derivative – [out] gradient of magnetic field vector as (3x3) matrix
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector
-
virtual Cache makeCache(const MagneticFieldContext &mctx) const = 0
Make an opaque cache for the magnetic field.
Instructs the specific implementation to generate a
Cache
instance for magnetic field lookup.- Parameters
mctx – The magnetic field context to generate cache for
- Returns
Cache The opaque cache object
-
using Cache = detail::SmallObjectCache
-
class Material
- #include <Acts/Material/Material.hpp>
Material description for interactions with matter.
The following parameters are used to specify the material and its interactions with traversing particles:
radiation length X0 (native length units)
nuclear interaction length L0 (native length units)
relative atomic mass Ar (unitless number)
nuclear charge number Z (elementary charge e)
molar density (native amount-of-substance unit / (native length unit)³)
The parameters can be effective or average parameters e.g. when a mixture of materials is described.
Note
Always use the opaque parameters vector to serialize/deserialize the material information. Since the internal storage might be different from the external accessors, this ensures that always the numerically optimal parameters are stored. Use the
ParametersVector
type and do not assume any particular size since we might consider to store more parameters in the future.Public Types
-
using ParametersVector = Eigen::Matrix<float, 5, 1>
Public Functions
-
Material() = default
Construct a vacuum representation.
-
Material(const ParametersVector ¶meters)
Construct from an encoded parameters vector.
-
Material(Material &&mat) = default
-
Material(const Material &mat) = default
-
~Material() = default
-
inline constexpr float Ar() const
Return the relative atomic mass.
-
inline constexpr float L0() const
Return the nuclear interaction length. Infinity in case of vacuum.
-
float massDensity() const
Return the mass density.
-
float meanExcitationEnergy() const
Return the mean electron excitation energy.
-
inline constexpr float molarDensity() const
Return the molar density.
-
inline constexpr float molarElectronDensity() const
Return the molar electron density.
-
inline constexpr operator bool() const
Check if the material is valid, i.e. it is not vacuum.
-
ParametersVector parameters() const
Encode the properties into an opaque parameters vector.
-
inline constexpr float X0() const
Return the radition length. Infinity in case of vacuum.
-
inline constexpr float Z() const
Return the nuclear charge number.
Public Static Functions
-
static Material fromMassDensity(float x0, float l0, float ar, float z, float massRho)
Construct from material parameters using the mass density.
Warning
Due to the choice of native mass units, using the mass density can lead to numerical problems. Typical mass densities lead to computations with values differing by 20+ orders of magnitude.
- Parameters
x0 – is the radiation length
l0 – is the nuclear interaction length
ar – is the relative atomic mass
z – is the nuclear charge number
massRho – is the mass density
-
static Material fromMolarDensity(float x0, float l0, float ar, float z, float molarRho)
Construct from material parameters using the molar density.
- Parameters
x0 – is the radiation length
l0 – is the nuclear interaction length
ar – is the relative atomic mass
z – is the nuclear charge number
molarRho – is the molar density
-
struct MaterialCollector
- #include <Acts/Material/MaterialCollector.hpp>
A Material Collector struct.
Public Types
-
using result_type = this_result
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t &state, const stepper_t &stepper, result_type &result) const Collector action for the ActionList of the Propagator It checks if the state has a current surface, in which case the action is performed:
it records the surface given the configuration
- Template Parameters
propagator_state_t – is the type of Propagator state
stepper_t – Type of the stepper of the propagation
- Parameters
state – is the mutable propagator state object
stepper – The stepper in use
result – is the result object to be filled
-
template<typename propagator_state_t>
inline void operator()(propagator_state_t&) const Pure observer interface.
this does not apply to the surface collector
Public Members
-
bool detailedCollection = false
In the detailed collection mode the material per surface is collected, otherwise only the total pathlength in X0 or L0 are recorded.
-
struct this_result
- #include <Acts/Material/MaterialCollector.hpp>
Simple result struct to be returned.
Result of the material collection process It collects the overall X0 and L0 path lengths, and optionally a detailed per-material breakdown
-
using result_type = this_result
-
class MaterialComposition
- #include <Acts/Material/MaterialComposition.hpp>
Material composed from multiple elements with varying factions.
See also
ElementFraction for details.
Public Functions
-
MaterialComposition() = default
Construct an empty composition corresponding to vacuum.
-
inline MaterialComposition(std::vector<ElementFraction> elements)
Constructor from element fractions.
Rescales the fractions so they all add up to unity within the accuracy.
-
MaterialComposition(MaterialComposition&&) = default
-
MaterialComposition(const MaterialComposition&) = default
-
~MaterialComposition() = default
-
inline auto begin() const
-
inline auto end() const
-
inline operator bool() const
Check if the composed material is valid, i.e. it is not vacuum.
-
MaterialComposition &operator=(MaterialComposition&&) = default
-
MaterialComposition &operator=(const MaterialComposition&) = default
-
inline size_t size() const
Return the number of elements.
-
MaterialComposition() = default
-
struct MaterialHit
- #include <Acts/Material/MaterialCollector.hpp>
The information to be writtern out per hit surface.
-
struct MaterialInteraction
- #include <Acts/Material/MaterialInteraction.hpp>
The Material interaction struct It records the surface and the passed material This is only nessecary recorded when configured.
Public Members
-
double deltaP = 0.0
The momentum change due to the interaction.
-
GeometryIdentifier intersectionID
The ID where the interaction occured.
-
MaterialSlab materialSlab
The effective, passed material properties including the path correction.
-
double pathCorrection = 1.
The path correction factor due to non-zero incidence on the surface.
-
double sigmaPhi2 = 0.0
Expected phi variance due to the interactions.
-
double sigmaQoP2 = 0.0
Expected q/p variance due to the interactions.
-
double sigmaTheta2 = 0.0
Expected theta variance due to the interactions.
-
const Surface *surface = nullptr
The surface where the interaction occured.
-
double time = 0.0
The particle time at the interaction.
-
bool updatedVolumeStep = false
Update the volume step to implment the proper step size.
-
const TrackingVolume *volume = nullptr
The volume where the interaction occured.
-
double deltaP = 0.0
-
struct MaterialInteractor
- #include <Acts/Propagator/MaterialInteractor.hpp>
Material interactor propagator action.
Apply material interactions at a surface and update the track state.
Public Types
-
using result_type = RecordedMaterial
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t &state, const stepper_t &stepper, result_type &result) const Interaction with detector material for the ActionList of the Propagator.
It checks if the state has a current surface, in which case the action is performed: the covariance is transported to the position, multiple scattering and energy loss is applied according to the configuration.
- Template Parameters
propagator_state_t – is the type of Propagagor state
stepper_t – Type of the stepper of the propagation
- Parameters
state – is the mutable propagator state object
stepper – The stepper in use
result – is the mutable result state object
-
template<typename propagator_state_t>
inline void operator()(propagator_state_t&) const Material interaction has no pure observer.
Public Members
-
bool energyLoss = true
Whether to consider energy loss.
-
bool multipleScattering = true
Whether to consider multiple scattering.
-
bool recordInteractions = false
Whether to record all material interactions.
-
using result_type = RecordedMaterial
-
class MaterialMapJsonConverter
- #include <Acts/Plugins/Json/MaterialMapJsonConverter.hpp>
read the material from Json
Public Types
-
using DetectorMaterialMaps = std::pair<SurfaceMaterialMap, VolumeMaterialMap>
-
using SurfaceMaterialMap = std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>>
-
using VolumeMaterialMap = std::map<GeometryIdentifier, std::shared_ptr<const IVolumeMaterial>>
Public Functions
-
MaterialMapJsonConverter(const Config &config, Acts::Logging::Level level)
Constructor.
- Parameters
config – configuration struct for the reader
level – The log level
-
~MaterialMapJsonConverter() = default
Destructor.
-
void convertToHierarchy(std::vector<std::pair<GeometryIdentifier, Acts::TrackingVolumeAndMaterial>> &volumeHierarchy, std::vector<std::pair<GeometryIdentifier, Acts::SurfaceAndMaterialWithContext>> &surfaceHierarchy, const Acts::TrackingVolume *tVolume)
Go through a volume to find subvolume, layers and surfaces.
Store volumes and surfaces in two vector used to initialised the geometry hierachy.
- Parameters
volumeHierarchy – is a vector of volume to be filled
surfaceHierarchy – is a vector of surfaces to be filled
tVolume – is a volume
-
DetectorMaterialMaps jsonToMaterialMaps(const nlohmann::json &materialmaps)
Convert a json material map to a DetectorMaterialMaps.
- Parameters
materialmaps – The json material
-
nlohmann::json materialMapsToJson(const DetectorMaterialMaps &maps)
Convert a DetectorMaterialMaps to json.
- Parameters
maps – The material map collection
-
nlohmann::json trackingGeometryToJson(const TrackingGeometry &tGeometry)
Convert a tracking geometry to json.
Can be used to initialise the material mapping process.
- Parameters
tGeometry – is the tracking geometry
-
class Config
- #include <Acts/Plugins/Json/MaterialMapJsonConverter.hpp>
Configuration of the Converter.
Public Members
-
GeometryContext context = GeometryContext()
Default geometry context to extract surface tranforms.
-
bool processApproaches = true
Steering to handle approach data.
-
bool processBoundaries = true
Steering to handle boundary data.
-
bool processDenseVolumes = false
Steering to handle volume data.
-
bool processNonMaterial = false
Add proto material to all surfaces.
-
bool processRepresenting = true
Steering to handle representing data.
-
bool processSensitives = true
Steering to handle sensitive data.
-
bool processVolumes = true
Steering to handle volume data.
-
GeometryContext context = GeometryContext()
-
using DetectorMaterialMaps = std::pair<SurfaceMaterialMap, VolumeMaterialMap>
-
template<typename G>
struct MaterialMapper - #include <Acts/Material/InterpolatedMaterialMap.hpp>
Struct for mapping global 3D positions to material values.
Global 3D positions are transformed into a
DIM_POS
Dimensional vector which is used to look up the material classification value in the underlying material map.Public Types
-
using Grid_t = G
Public Functions
-
inline MaterialMapper(std::function<ActsVector<DIM_POS>(const Vector3&)> transformPos, Grid_t grid)
Default constructor.
- Parameters
transformPos – [in] Mapping of global 3D coordinates (cartesian) onto grid space
grid – [in] Grid storing material classification values
-
inline const Grid_t &getGrid() const
Get a const reference on the underlying grid structure.
- Returns
Grid reference
-
inline Material getMaterial(const Vector3 &position) const
Retrieve interpolated material at given position.
- Parameters
position – [in] Global 3D position
- Returns
Material at the given position
- Pre
The given
position
must lie within the range of the underlying map.
-
inline MaterialCell getMaterialCell(const Vector3 &position) const
Retrieve material cell for given position.
- Parameters
position – [in] Global 3D position
- Returns
material cell containing the given global position
- Pre
The given
position
must lie within the range of the underlying map.
-
inline std::vector<double> getMax() const
Get the maximum value of all axes of the map.
- Returns
Vector returning the maxima of all map axes
-
inline std::vector<double> getMin() const
Get the minimum value of all axes of the map.
- Returns
Vector returning the minima of all map axes
-
inline std::vector<size_t> getNBins() const
Get the number of bins for all axes of the map.
- Returns
Vector returning number of bins for all map axes
-
inline bool isInside(const Vector3 &position) const
Check whether given 3D position is inside look-up domain.
- Parameters
position – [in] Global 3D position
- Returns
true
if position is inside the defined look-up grid, otherwisefalse
Public Static Attributes
-
static constexpr size_t DIM_POS = Grid_t::DIM
-
struct MaterialCell
- #include <Acts/Material/InterpolatedMaterialMap.hpp>
Struct representing smallest grid unit in material grid.
This type encapsulate all required information to perform linear interpolation of material classification values within a 3D volume.
Public Functions
-
inline MaterialCell(std::function<ActsVector<DIM_POS>(const Vector3&)> transformPos, std::array<double, DIM_POS> lowerLeft, std::array<double, DIM_POS> upperRight, std::array<Material::ParametersVector, N> materialValues)
Default constructor.
- Parameters
transformPos – [in] Mapping of global 3D coordinates onto grid space
lowerLeft – [in] Generalized lower-left corner of hyper box (containing the minima of the hyper box along each Dimension)
upperRight – [in] Generalized upper-right corner of hyper box (containing the maxima of the hyper box along each Dimension)
materialValues – [in] Material classification values at the hyper box corners sorted in the canonical order defined in Acts::interpolate
-
inline Material getMaterial(const Vector3 &position) const
Retrieve material at given position.
- Parameters
position – [in] Global 3D position
- Returns
Material at the given position
- Pre
The given
position
must lie within the current cell.
-
inline bool isInside(const Vector3 &position) const
Check whether given 3D position is inside this cell.
- Parameters
position – [in] Global 3D position
- Returns
true
if position is inside the current cell, otherwisefalse
Public Static Attributes
-
static constexpr unsigned int N = 1 << DIM_POS
Number of corner points defining the confining hyper-box.
-
inline MaterialCell(std::function<ActsVector<DIM_POS>(const Vector3&)> transformPos, std::array<double, DIM_POS> lowerLeft, std::array<double, DIM_POS> upperRight, std::array<Material::ParametersVector, N> materialValues)
-
using Grid_t = G
-
class MaterialSlab
- #include <Acts/Material/MaterialSlab.hpp>
Material description for an object with defined thickness.
This is intended to describe concrete surface materials.
See also
Material for a description of the available parameters.
Public Functions
-
MaterialSlab() = default
Construct vacuum without thickness.
-
MaterialSlab(float thickness)
Construct vacuum with thickness.
-
MaterialSlab(const Material &material, float thickness)
Construct from material description.
- Parameters
material – is the material description
thickness – is the thickness of the material
-
MaterialSlab(const std::vector<MaterialSlab> &layers)
Construct by averaging the material properties over multiple layers.
The resulting object has the combined thickness of all layers but just one set of appropriately averaged material constants.
- Parameters
layers – Input layers to average over.
-
MaterialSlab(MaterialSlab&&) = default
-
MaterialSlab(const MaterialSlab&) = default
-
~MaterialSlab() = default
-
inline constexpr const Material &material() const
Access the (average) material parameters.
-
inline constexpr operator bool() const
Check if the material is valid, i.e. it is finite and not vacuum.
-
MaterialSlab &operator=(MaterialSlab&&) = default
-
MaterialSlab &operator=(const MaterialSlab&) = default
-
void scaleThickness(float scale)
Scale the material thickness by the given factor.
-
inline constexpr float thickness() const
Return the thickness.
-
inline constexpr float thicknessInL0() const
Return the nuclear interaction length fraction.
-
inline constexpr float thicknessInX0() const
Return the radiation length fraction.
-
MaterialSlab() = default
-
struct MaterialSurface
- #include <Acts/Material/SurfaceMaterialMapper.hpp>
selector for finding surface
Public Functions
-
inline bool operator()(const Surface &sf) const
-
inline bool operator()(const Surface &sf) const
-
struct MaterialVolume
- #include <Acts/Material/SurfaceMaterialMapper.hpp>
selector for finding volume
Public Functions
-
inline bool operator()(const TrackingVolume &vf) const
-
inline bool operator()(const TrackingVolume &vf) const
-
struct MaxMomentumReducerLoop
- #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
Public Static Functions
-
template<typename stepper_state_t>
static inline ActsScalar charge(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline FreeVector cov(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline Vector3 direction(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline ActsScalar momentum(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline FreeVector pars(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline Vector3 position(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline ActsScalar time(const stepper_state_t &s)
-
template<typename stepper_state_t>
-
template<typename indices_t, size_t kSize>
class Measurement - #include <Acts/EventData/Measurement.hpp>
A measurement of a fixed-size subspace of the full parameters.
The measurement intentionally does not store a pointer/reference to the reference object in the geometry hierarchy, i.e. the surface or volume. The reference object can already be identified via the geometry identifier provided by the source link. Since a measurement must be anchored within the geometry hierarchy, all measurement surfaces and volumes must provide valid geometry identifiers. In all use-cases, e.g. Kalman filtering, a pointer/reference to the reference object is available before the measurement is accessed; e.g. the propagator provides the surface pointer during navigation, which is then used to lookup possible measurements.
The pointed-to geometry object would differ depending on the parameter type. This means either, that there needs to be an additional variable type or that a pointer to a base object is stored (requiring a
dynamic_cast
later on). Both variants add additional complications. Since the geometry object is not required anyways (as discussed above), not storing it removes all these complications altogether.- Template Parameters
indices_t – Parameter index type, determines the full parameter space
kSize – Size of the parameter subset.
Public Types
-
using CovarianceMatrix = ActsSymMatrix<kSize>
Matrix type for the measurement covariance.
-
using ExpansionMatrix = ActsMatrix<kFullSize, kSize>
-
using FullParametersVector = ActsVector<kFullSize>
Vector type containing all parameters in the same space.
-
using ParametersVector = ActsVector<kSize>
Vector type containing for measured parameter values.
-
using ProjectionMatrix = ActsMatrix<kSize, kFullSize>
-
using Scalar = ActsScalar
Public Functions
-
template<typename parameters_t, typename covariance_t>
inline Measurement(const SourceLink &source, const std::array<indices_t, kSize> &indices, const Eigen::MatrixBase<parameters_t> ¶ms, const Eigen::MatrixBase<covariance_t> &cov) Construct from source link, subset indices, and measured data.
Note
The indices must be ordered and must describe/match the content of parameters and covariance.
- Template Parameters
parameters_t – Input parameters vector type
covariance_t – Input covariance matrix type
- Parameters
source – The link that connects to the underlying detector readout
indices – Which parameters are measured
params – Measured parameters values
cov – Measured parameters covariance
-
Measurement() = delete
A measurement can only be constructed with valid parameters.
-
Measurement(const Measurement&) = default
-
Measurement(Measurement&&) = default
-
~Measurement() = default
-
inline bool contains(indices_t i) const
Check if a specific parameter is part of this measurement.
-
inline const CovarianceMatrix &covariance() const
Measured parameters covariance.
-
inline ExpansionMatrix expander() const
Expansion matrix from the measured subspace into the full space.
This is equivalent to the tranpose of the projection matrix only in the case of a trivial projection matrix. While this is the case here, it is still recommended to use the expansion matrix directly in cases where it is explicitely used.
-
inline std::ostream &operator<<(std::ostream &os) const
-
Measurement &operator=(const Measurement&) = default
-
Measurement &operator=(Measurement&&) = default
-
inline const ParametersVector ¶meters() const
Measured parameters values.
-
inline ProjectionMatrix projector() const
Projection matrix from the full space into the measured subspace.
-
inline ParametersVector residuals(const FullParametersVector &reference) const
Compute residuals in the measured subspace.
This computes the difference
measured - reference
taking into account the allowed parameter ranges. Only the reference values in the measured subspace are used for the computation.- Parameters
reference – Reference parameters in the full space.
-
inline const SourceLink &sourceLink() const
Source link that connects to the underlying detector readout.
Public Static Functions
-
static inline constexpr size_t size()
Number of measured parameters.
-
class MeasurementSelector
- #include <Acts/TrackFinding/MeasurementSelector.hpp>
Measurement selection struct selecting those measurements compatible with the given track parameter against provided criteria on one surface.
The selection criteria could be allowed maximum chi2 and allowed maximum number of measurements on one surface
If there is no compatible measurement, the measurement with the mininum chi2 will be selected and the status will be tagged as an outlier
Public Types
-
using Config = Acts::GeometryHierarchyMap<MeasurementSelectorCuts>
Geometry-dependent cut configuration.
Different components on the geometry can require different cut settings. The configuration must either contain explicit settings for all geometry components that are used or contain a global default.
Public Functions
-
MeasurementSelector() = default
Default constructor.
-
inline MeasurementSelector(Config config)
Constructor with config and (non-owning) logger.
- Parameters
config – a config instance
-
template<typename traj_t>
inline Result<std::pair<typename std::vector<typename MultiTrajectory<traj_t>::TrackStateProxy>::iterator, typename std::vector<typename MultiTrajectory<traj_t>::TrackStateProxy>::iterator>> select(std::vector<typename MultiTrajectory<traj_t>::TrackStateProxy> &candidates, bool &isOutlier, LoggerWrapper logger) const Function that select the measurements compatible with the given track parameter on a surface.
- Parameters
candidates – The track state candidates which already contain predicted parameters
isOutlier – The indicator for outlier or not
logger – The logger wrapper
- Returns
Pair of iterators into candidates marking the range of selected candidates
-
using Config = Acts::GeometryHierarchyMap<MeasurementSelectorCuts>
-
struct MeasurementSelectorCuts
- #include <Acts/TrackFinding/MeasurementSelector.hpp>
Selection cuts for associating measurements with predicted track parameters on a surface.
The default configuration only takes the best matching measurement without a cut on the local chi2.
Public Members
-
std::vector<double> chi2CutOff = {std::numeric_limits<double>::max()}
Maximum local chi2 contribution.
-
std::vector<double> etaBins
bins in |eta| to specify variable selections
-
std::vector<size_t> numMeasurementsCutOff = {1}
Maximum number of associated measurements on a single surface.
-
std::vector<double> chi2CutOff = {std::numeric_limits<double>::max()}
-
class MLTrackClassifier : public Acts::OnnxRuntimeBase
- #include </home/docs/checkouts/readthedocs.org/user_builds/acts/checkouts/v20.2.0/Plugins/Onnx/include/Acts/Plugins/Onnx/MLTrackClassifier.hpp>
Public Types
-
enum TrackLabels
The labels for track quality.
Values:
-
enumerator eGood
-
enumerator eDuplicate
-
enumerator eFake
-
enumerator eGood
Public Functions
-
bool isDuplicate(std::vector<float> &inputFeatures, double decisionThreshProb) const
Check if the predicted track label is ‘duplicate’.
- Parameters
inputFeatures – The vector of input features for the trajectory to be classified
decisionThreshProb – The probability threshold used to predict the track label
- Returns
If the predicted track label is ‘duplicate’
-
TrackLabels predictTrackLabel(std::vector<float> &inputFeatures, double decisionThreshProb) const
Predict the track label.
- Parameters
inputFeatures – The vector of input features for the trajectory to be classified
decisionThreshProb – The probability threshold used to predict the track label
- Returns
The predicted track label of the trajectory
-
enum TrackLabels
-
template<typename charge_t>
class MultiComponentBoundTrackParameters - #include <Acts/EventData/MultiComponentBoundTrackParameters.hpp>
This class is only a light wrapper arround a surface and a vector of parameters.
Its main purpose is to provide many constructors for the underlying vector. Most accessors are generated from the SingleBoundTrackParameters equivalent and thus may be expensive
Note
This class holds shared ownership on its reference surface.
Note
The accessors for parameters, covariance, position, etc. are the weighted means of the components.
Note
If all covariances are zero, the accessor for the total covariance does return std::nullopt; TODO Add constructor from range and projector maybe?
- Template Parameters
charge_t – Helper type to interpret the particle charge/momentum
Public Types
-
using CovarianceMatrix = typename SingleParameters::CovarianceMatrix
-
using ParametersVector = typename SingleParameters::ParametersVector
-
using Scalar = typename SingleParameters::Scalar
Public Functions
Construct from multiple components with charge scalar q.
Construct from multiple components with charge_t.
Construct from a parameters vector on the surface and particle charge.
In principle, only the charge magnitude is needed her to allow unambigous extraction of the absolute momentum. The particle charge is required as an input here to be consistent with the other constructors below that that also take the charge as an input. The charge sign is only used in debug builds to check for consistency with the q/p parameter.
- Parameters
surface – Reference surface the parameters are defined on
params – Bound parameters vector
q – Particle charge
cov – Bound parameters covariance matrix
Construct from a parameters vector on the surface.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge type is default-constructible.
- Parameters
surface – Reference surface the parameters are defined on
params – Bound parameters vector
cov – Bound parameters covariance matrix
-
MultiComponentBoundTrackParameters() = delete
Parameters are not default constructible due to the charge type.
-
MultiComponentBoundTrackParameters(const MultiComponentBoundTrackParameters&) = default
-
MultiComponentBoundTrackParameters(MultiComponentBoundTrackParameters&&) = default
-
~MultiComponentBoundTrackParameters() = default
-
inline Scalar absoluteMomentum() const
Absolute momentum.
-
inline Scalar charge() const
Particle electric charge.
-
inline const auto &components() const
Access the parameters.
-
inline std::optional<CovarianceMatrix> covariance() const
Optional covariance matrix.
-
inline Vector4 fourPosition(const GeometryContext &geoCtx) const
Space-time position four-vector.
- Parameters
geoCtx – [in] Geometry context for the local-to-global transformation
-
inline Vector3 momentum() const
Momentum three-vector.
-
MultiComponentBoundTrackParameters &operator=(const MultiComponentBoundTrackParameters&) = default
-
MultiComponentBoundTrackParameters &operator=(MultiComponentBoundTrackParameters&&) = default
-
inline std::pair<double, SingleParameters> operator[](std::size_t i) const
Get the weight and a SingleBoundTrackParameters object for one component.
-
inline ParametersVector parameters() const
Parameters vector.
-
inline Vector3 position(const GeometryContext &geoCtx) const
Spatial position three-vector.
- Parameters
geoCtx – [in] Geometry context for the local-to-global transformation
-
inline const Surface &referenceSurface() const
Reference surface onto which the parameters are bound.
-
inline Scalar time() const
Time coordinate.
-
inline Scalar transverseMomentum() const
Transverse momentum.
-
inline Vector3 unitDirection() const
Unit direction three-vector, i.e.
the normalized momentum three-vector.
-
template<typename extensionlist_t = StepperExtensionList<DefaultExtension>, typename component_reducer_t = WeightedComponentReducerLoop, typename auctioneer_t = detail::VoidAuctioneer>
class MultiEigenStepperLoop : public Acts::EigenStepper<extensionlist_t, auctioneer_t> - #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
Stepper based on the EigenStepper, but handles Multi-Component Tracks (e.g., for the GSF).
Internally, this only manages a vector of EigenStepper::States. This simplifies implementation, but has several drawbacks:
There are certain redundancies between the global State and the component states
The components do not share a single magnetic-field-cache
- Template Parameters
extensionlist_t – See EigenStepper for details
component_reducer_t – How to map the multi-component state to a single component
auctioneer_t – See EigenStepper for details
small_vector_size – A size-hint how much memory should be allocated by the small vector
Public Types
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
using ConstComponentProxy = ComponentProxyBase<const typename State::Component>
A proxy struct which allows access to a single component of the multi-component state.
It has the semantics of a const reference, i.e. it requires a const reference of the single-component state it represents
-
using Covariance = BoundSymMatrix
-
using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>
-
using Jacobian = BoundMatrix
Jacobian, Covariance and State defintions.
-
using Reducer = component_reducer_t
The reducer type.
-
using SingleState = typename SingleStepper::State
Typedef to the State of the single component Stepper.
-
using SingleStepper = EigenStepper<extensionlist_t, auctioneer_t>
Typedef to the Single-Component Eigen Stepper.
Public Functions
Constructor from a magnetic field and a optionally provided Logger.
-
template<typename charge_t>
inline Result<ComponentProxy> addComponent(State &state, const SingleBoundTrackParameters<charge_t> &pars, double weight) const Add a component to the Multistepper.
Note
This function makes no garantuees about how new components are initialized, it is up to the caller to ensure that all components are valid in the end.
Note
The returned component-proxy is only garantueed to be valid until the component number is again modified
-
Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Create and return the bound state at the current position.
This transports (if necessary) the covariance to the surface and creates a bound state. It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator.
Note
This is done by combining the gaussian mixture on the specified surface. If the conversion to bound states of some components failes, these components are ignored unless all components fail. In this case an error code is returned.
- Parameters
state – [in] State that will be presented as
BoundState
surface – [in] The surface to which we bind the state
transportCov – [in] Flag steering covariance transport
freeToBoundCorrection – [in] Flag steering non-linear correction during global to local correction
- Returns
A bound state:
the parameters at the surface
the stepwise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline double charge(const State &state) const
Charge access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline void clearComponents(State &state) const
Reset the number of components.
-
inline auto componentIterable(State &state) const
Creates an iterable which can be plugged into a range-based for-loop to iterate over components.
Note
Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference
-
inline auto constComponentIterable(const State &state) const
Creates an constant iterable which can be plugged into a range-based for-loop to iterate over components.
Note
Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference
-
CurvilinearState curvilinearState(State &state, bool transportCov = true) const
Create and return a curvilinear state at the current position.
This transports (if necessary) the covariance to the current position and creates a curvilinear state.
Note
This is done as a simple average over the free representation and covariance of the components.
- Parameters
state – [in] State that will be presented as
CurvilinearState
transportCov – [in] Flag steering covariance transport
- Returns
A curvilinear state:
the curvilinear parameters at given position
the stepweise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline Vector3 direction(const State &state) const
Momentum direction accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline Result<Vector3> getField(State &state, const Vector3 &pos) const
Get the field for the stepping, it checks first if the access is still within the Cell, and updates the cell if necessary.
Note
This uses the cache of the first component stored in the state
- Parameters
state – [inout] is the propagation state associated with the track the magnetic field cell is used (and potentially updated)
pos – [in] is the field position
-
inline double getStepSize(const State &state, ConstrainedStep::Type stype) const
Get the step size.
Note
This returns the smalles step size of all components. It uses std::abs for comparison to handle backward propagation and negative step sizes correctly.
- Parameters
state – [in] The stepping state (thread-local cache)
stype – [in] The step size type to be returned
Construct and initialize a state.
-
inline double momentum(const State &state) const
Absolute momentum accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline std::size_t numberComponents(const State &state) const
Get the number of components.
-
inline std::string outputStepSize(const State &state) const
Output the Step Size of all components into one std::string.
- Parameters
state – [in,out] The stepping state (thread-local cache)
-
inline double overstepLimit(const State &state) const
Overstep limit.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline Vector3 position(const State &state) const
Global particle position accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline void releaseStepSize(State &state) const
Release the step-size for all components.
- Parameters
state – [in,out] The stepping state (thread-local cache)
-
inline void removeMissedComponents(State &state) const
Remove missed components from the component state.
Resets the state.
- Parameters
state – [inout] State of the stepper
boundParams – [in] Parameters in bound parametrisation
cov – [in] Covariance matrix
surface – [in] The reference surface of the bound parameters
navDir – [in] Navigation direction
stepSize – [in] Step size
-
inline void setStepSize(State &state, double stepSize, ConstrainedStep::Type stype = ConstrainedStep::actor, bool release = true) const
Set Step size - explicitely with a double.
- Parameters
state – [in,out] The stepping state (thread-local cache)
stepSize – [in] The step size value
stype – [in] The step size type to be set
release – [in] Do we release the step size?
-
template<typename propagator_state_t>
Result<double> step(propagator_state_t &state) const Perform a Runge-Kutta track parameter propagation step.
The state contains the desired step size. It can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.
- Parameters
state – [inout] is the propagation state associated with the track parameters that are being propagated.
-
inline double time(const State &state) const
Time access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
Note
no check is done if the position is actually on the surface
- Template Parameters
surface_t – the Surface type
- Parameters
state – [inout] State of the stepper
surface – [in] is the surface to which the covariance is forwarded
freeToBoundCorrection – [in] Flag steering non-linear correction during global to local correction to
-
inline void transportCovarianceToCurvilinear(State &state) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.
- Parameters
state – [inout] State of the stepper
-
template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, bool release = true) const Update step size.
This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.
- Parameters
state – [in,out] The stepping state (thread-local cache)
oIntersection – [in] The ObjectIntersection to layer, boundary, etc
release – [in] boolean to trigger step size release
-
inline Intersection3D::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck, LoggerWrapper logger = getDummyLogger()) const
Update surface status.
It checks the status to the reference surface & updates the step size accordingly
- Parameters
state – [in,out] The stepping state (thread-local cache)
surface – [in] The surface provided
bcheck – [in] The boundary check for this status update
logger – [in] A
LoggerWrapper
instance
Public Static Attributes
-
static constexpr int maxComponents = std::numeric_limits<int>::max()
How many components can this stepper manage?
-
struct ComponentProxy : public Acts::MultiEigenStepperLoop<extensionlist_t, component_reducer_t, auctioneer_t>::ComponentProxyBase<State::Component>
- #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
A proxy struct which allows access to a single component of the multi-component state.
It has the semantics of a mutable reference, i.e. it requires a mutable reference of the single-component state it represents
Public Types
-
using Base = ComponentProxyBase<typename State::Component>
Public Functions
-
inline Result<BoundState> boundState(const Surface &surface, bool transportCov, const FreeToBoundCorrection &freeToBoundCorrection)
-
inline auto &charge()
-
inline auto &cov()
-
inline auto &derivative()
-
inline auto &jacobian()
-
inline auto &jacToGlobal()
-
inline auto &jacTransport()
-
inline auto &pars()
-
inline auto &pathAccumulated()
-
template<typename propagator_state_t>
inline auto singleState(propagator_state_t &state)
-
inline auto &status()
-
inline void update(const FreeVector &freeParams, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface)
-
inline auto &weight()
Public Members
-
const State &all_state
-
using Base = ComponentProxyBase<typename State::Component>
-
template<typename component_t>
struct ComponentProxyBase - #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
A template class which contains all const member functions, that should be available both in the mutable ComponentProxy and the ConstComponentProxy.
- Template Parameters
component_t – Must be a const or mutable State::Component.
Public Functions
-
inline ComponentProxyBase(component_t &c)
-
inline auto charge() const
-
inline const auto &cov() const
-
inline const auto &derivative() const
-
inline const auto &jacobian() const
-
inline const auto &jacToGlobal() const
-
inline const auto &jacTransport() const
-
inline const auto &pars() const
-
inline auto pathAccumulated() const
-
template<typename propagator_state_t>
inline auto singleState(const propagator_state_t &state) const
-
inline const auto &singleStepper(const MultiEigenStepperLoop &stepper) const
-
inline auto status() const
-
inline auto weight() const
Public Members
-
component_t &cmp
-
template<typename stepping_t, typename navigation_t, typename options_t, typename geoctx_t>
struct SinglePropState - #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
A helper type for providinig a propagation state which can be used with functions expecting single-component steppers and states.
Public Functions
-
struct State
- #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
Public Functions
-
State() = delete
No default constructor is provided.
Constructor from the initial bound track parameters.
Note
the covariance matrix is copied when needed
- Template Parameters
charge_t – Type of the bound parameter charge
- Parameters
gctx – [in] is the context object for the geometry
mctx – [in] is the context object for the magnetic field
bfield – [in] the shared magnetic filed provider
multipars – [in] The track multi-component track-parameters at start
ndir – [in] The navigation direction w.r.t momentum
ssize – [in] is the maximum step size
stolerance – [in] is the stepping tolerance
Public Members
-
SmallVector<Component> components
The components of which the state consists.
-
bool covTransport = false
-
std::reference_wrapper<const GeometryContext> geoContext
geoContext
-
std::reference_wrapper<const MagneticFieldContext> magContext
MagneticFieldContext.
-
double pathAccumulated = 0.
-
std::optional<std::size_t> stepCounterAfterFirstComponentOnSurface
Step-limit counter which limits the number of steps when one component reached a surface.
-
int steps = 0
-
struct Component
- #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
The struct that stores the individual components.
-
State() = delete
-
template<typename T, std::size_t... BitsPerLevel>
class MultiIndex - #include <Acts/Utilities/MultiIndex.hpp>
A set of (hierachical) indices bitpacked into a single value.
The underlying value is split into blocks of bits with variable size. Each block is a level within the index hierachy and can be set and retrieved separately. The encoded MultiIndex can be ordered and compared for equality. The ordering follows the hiearchy, i.e. indices are first ordered by the highest level, then within the highest level by the second level and so on.
Public Types
-
enum [anonymous]
Values:
-
enumerator NumLevels
-
enumerator NumLevels
-
using Value = T
The type of ther underlying storage value.
Public Functions
-
inline constexpr MultiIndex(Value encoded)
Construct a MultiIndex from an already encoded value.
-
MultiIndex() = default
Construct a default MultiIndex with undefined values for each level.
-
MultiIndex(const MultiIndex&) = default
-
MultiIndex(MultiIndex&) = default
-
inline constexpr Value level(std::size_t lvl) const
Get the value for the index level.
-
inline constexpr MultiIndex makeLastDescendant(std::size_t lvl) const
Create index with every level below the selected level maximized.
-
inline constexpr MultiIndex makeNextSibling(std::size_t lvl) const
Create index with the selected level increased and levels below zeroed.
-
MultiIndex &operator=(const MultiIndex&) = default
-
MultiIndex &operator=(MultiIndex&&) = default
-
inline constexpr MultiIndex &operator=(Value encoded)
Allow setting the MultiIndex from an already encoded value.
-
inline constexpr MultiIndex &set(std::size_t lvl, Value val)
Set the value of the index level.
-
inline constexpr Value value() const
Get the encoded value of all index levels.
Public Static Functions
-
static inline constexpr std::size_t bits(std::size_t lvl)
Get the number of bits for the associated level.
-
template<typename ...Us>
static inline constexpr MultiIndex Encode(Us&&... us) Construct a MultiIndex from values for multiple level.
This functionality must be implemented as a static, named constructor to avoid confusion with other constructors. If it would be implemented as a regular constructor, constructing a MultiIndex from a single encoded value and encoding only the first level would have the same signature and could not be distinguished.
-
static inline constexpr MultiIndex Zeros()
Construct a MultiIndex with all levels set to zero.
-
enum [anonymous]
-
struct MultiStepperSurfaceReached
- #include <Acts/Propagator/MultiStepperAborters.hpp>
This.
Public Functions
-
MultiStepperSurfaceReached() = default
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] Stepper used for propagation
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper, const Surface &targetSurface) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] Stepper used for the progation
targetSurface – [in] The target surface
-
MultiStepperSurfaceReached() = default
-
template<typename derived_t>
class MultiTrajectory - #include <Acts/EventData/MultiTrajectory.hpp>
Store a trajectory of track states with multiple components.
This container supports both simple, sequential trajectories as well as combinatorial or multi-component trajectories. Each point can store a parent point such that the trajectory forms a directed, acyclic graph of sub-trajectories. From a set of endpoints, all possible sub-components can be easily identified. Some functionality is provided to simplify iterating over specific sub-components.
Public Types
-
using ConstTrackStateProxy = detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, true>
-
using Derived = derived_t
-
using IndexType = typename TrackStateProxy::IndexType
-
using TrackStateProxy = detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, false>
Public Functions
-
template<typename T>
inline constexpr void addColumn(const std::string &key) Add a column to the
MultiTrajectory
.Note
This takes a string argument rather than a hashed string to maintain compatibility with backends.
- Template Parameters
T – Type of the column values to add
-
inline constexpr IndexType addTrackState(TrackStatePropMask mask = TrackStatePropMask::All, IndexType iprevious = kInvalid)
Add a track state without providing explicit information.
Which components of the track state are initialized/allocated can be controlled via
mask
- Parameters
mask – The bitmask that instructs which components to allocate and which to leave invalid
iprevious – index of the previous state, kInvalid if first
- Returns
Index of the newly added track state
-
template<typename F>
void applyBackwards(IndexType iendpoint, F &&callable) Apply a function to all previous states starting at a given endpoint.
Warning
If the trajectory contains multiple components with common points, this can have an impact on the other components.
- Parameters
iendpoint – index of the last state
callable – modifying functor to be called with each point
-
inline constexpr void clear()
Clear the
MultiTrajectory
. Leaves the underlying storage untouched.
-
inline ConstTrackStateProxy getTrackState(IndexType istate) const
Access a read-only point on the trajectory by index.
- Parameters
istate – The index to access
- Returns
Read only proxy to the stored track state
-
inline TrackStateProxy getTrackState(IndexType istate)
Access a writable point on the trajectory by index.
- Parameters
istate – The index to access
- Returns
Read-write proxy to the stored track state
-
inline constexpr bool hasColumn(HashedString key) const
Check if a column with a key
key
exists.- Parameters
key – Key to check for a column with
- Returns
True if the column exists, false if not.
-
inline constexpr IndexType size() const
Returns the number of track states contained.
Public Static Attributes
-
static constexpr IndexType kInvalid = TrackStateProxy::kInvalid
-
static constexpr unsigned int MeasurementSizeMax = MultiTrajectoryTraits::MeasurementSizeMax
Friends
- friend class detail_lt::TrackStateProxy< Derived, MeasurementSizeMax, false >
- friend class detail_lt::TrackStateProxy< Derived, MeasurementSizeMax, true >
-
using ConstTrackStateProxy = detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, true>
- #include <Acts/Geometry/NavigationLayer.hpp>
Class to be used for gaps in Volumes as a navigational link.
Navigation Layers have a surface representation, but should usually never be propagated to.
Public Functions
Default Constructor - deleted.
Copy Constructor - deleted.
Destructor.
The binning position method.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the value for which the binning position is requested
as default the center is given, but may be overloaded
- Returns
The return vector can be used for binning in a TrackingVolume
Geometric isOnLayer() method using isOnSurface() with Layer specific tolerance.
- Parameters
gctx – The current geometry context object, e.g. alignment
gp – is the global position for the check
bcheck – is the boundary check directive
- Returns
boolean that indicates if the position is on surface
Assignment operator - deleted.
Accept layer according to the following colelction directives.
Note
navigation layers are never accepted
- Parameters
resolveSensitive – is the prescription to find the sensitive surfaces
resolveMaterial – is the precription to find material surfaces
resolvePassive – is the prescription to find all passive surfaces
- Returns
a boolean whether the layer is accepted for processing
Transforms the layer into a Surface representation for extrapolation In general, extrapolation to a surface should be avoided.
Public Static Functions
Factory Constructor - the surface representation is given by pointer (ownership passed)
- Parameters
sRepresentation – is the representation for extrapolation
thickness – is the thickness for the binning
- #include <Acts/Geometry/Layer.hpp>
struct for the Navigation options that are forwarded to the geometry
- Template Parameters
propagator_state_t – Type of the object for navigation state
object_t – Type of the object for navigation to check against
Public Functions
Constructor.
- Parameters
ndir – Navigation direction prescription
bcheck – Boundary check for the navigation action
resolves – Boolean whether to resolve sensitives
resolvem – Boolean whether to resolve material
resolvep – Boolean whether to resolve passives
sobject – Start object to check against
eobject – End object to check against
Public Members
The boundary check directive.
object to check against: at end
External surface identifier for which the boundary check is ignored.
The navigation direction.
The overstep tolerance for this navigation step.
Note
must be negative as it describes overstepping
The maximum path limit for this navigation step.
Always look for material.
always look for passive
Always look for sensitive.
object to check against: at start
Target surface to exclude.
- #include <Acts/Propagator/Navigator.hpp>
Navigator class.
This is an Actor to be added to the ActorList in order to navigate through the static tracking geometry setup.
The current navigation stage is cached in the state struct and updated when necessary. If any surface in the extrapolation flow is hit, it is set to the propagation satate, such that other actors can deal wit it. This navigation actor thus always needs to run first! It does two things: it figures out the order of volumes, layers and surfaces. For each propagation step, the operator() runs, which checks if the current surface (or layer/volume boundary) is reached.
The current target surface is the surface pointed to by of the iterators for the surfaces, layers or volume boundaries. If a surface is found, the state.navigation.currentSurface pointer is set. This enables subsequent actors to react. Secondly, this actor uses the ordered iterators to figure out which surface, layer or volume boundary is supposed to be hit next. It then sets the maximum step size to the path length found out by straight line intersection. If the state is not on surface, it also re-computes the step size, to make sure we end up at the desired surface.
Public Types
The navigation stage.
Values:
Public Functions
Constructor with configuration object.
- Parameters
cfg – The navigator configuration
Navigator status call, will be called in two modes.
(a) It initializes the Navigation stream if start volume is not yet defined:
initialize the volume
establish the start layer and start volume
set the current surface to the start surface
(b) It establishes the currentSurface status during the propagation flow, currentSurface can be
surfaces still to be handled within a layer
layers still to be handled within a volume
boundaries still to be handled to exit a volume
- Template Parameters
propagator_state_t – is the type of Propagatgor state
stepper_t – is the used type of the Stepper by the Propagator
- Parameters
state – [inout] is the mutable propagator state object
stepper – [in] Stepper in use
Navigator target call.
Call options (a) there are still surfaces to be resolved: handle those (b) there no surfaces but still layers to be resolved, handle those (c) there are no surfaces nor layers to be resolved, handle boundary
- Template Parameters
propagator_state_t – is the type of Propagatgor state
stepper_t – is the used type of the Stepper by the Propagator
- Parameters
state – [inout] is the mutable propagator state object
stepper – [in] Stepper in use
- #include <Acts/Propagator/Navigator.hpp>
Public Members
stop at every material surface (whether it is passive or not)
stop at every surface regardless what it is
Configuration for this Navigator stop at every sensitive surface (whether it has material or not)
The tolerance used to defined “reached”.
Tracking Geometry for this Navigator.
- #include <Acts/Propagator/Navigator.hpp>
Nested State struct.
It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information
Public Functions
Reset state.
- Parameters
geoContext – is the geometry context
pos – is the global position
dir – is the momentum direction
navDir – is the navigation direction
ssurface – is the new starting surface
tsurface – is the target surface
Public Members
Navigation state - external state: the current surface.
Navigation state: the current volume.
Externally provided surfaces - these are tried to be hit.
Indicator that the last VolumeHierarchy surface was reached skip the next layer targeting to the next boundary/volume.
the vector of boundary surfaces to work through
the current boundary iterator of the navigation state
Navigation state : a break has been detected.
the current layer iterator of the navigation state
the vector of navigation layers to work through
the current surface iterator of the navigation state
the vector of navigation surfaces to work through
Navigation state: the start layer.
Indicator for start layer treatment.
Navigation state: the start surface.
Navigation state: the start volume.
Navigation state: the target layer.
Indicator if the target is reached.
Navigation state: the target surface.
Navigation state: the target volume.
Navigation sate: the world volume.
-
template<typename external_spacepoint_t>
class Neighborhood - #include <Acts/Seeding/BinnedSPGroup.hpp>
Neighborhood
Used to access iterators to access a group of bins returned by a BinFinder.Fulfills the range_expression interface
Public Functions
-
Neighborhood() = delete
-
inline Neighborhood(NeighborhoodVector indices, const SpacePointGrid<external_spacepoint_t> *spgrid)
-
inline NeighborhoodIterator<external_spacepoint_t> begin()
-
inline NeighborhoodIterator<external_spacepoint_t> end()
-
Neighborhood() = delete
-
template<typename external_spacepoint_t>
class NeighborhoodIterator - #include <Acts/Seeding/BinnedSPGroup.hpp>
Iterates over the elements of all bins given by the indices parameter in the given SpacePointGrid.
Fullfills the forward iterator.
Public Types
-
using sp_it_t = typename std::vector<std::unique_ptr<InternalSpacePoint<external_spacepoint_t>>>::const_iterator
Public Functions
-
NeighborhoodIterator() = delete
-
inline NeighborhoodIterator(NeighborhoodVector indices, const SpacePointGrid<external_spacepoint_t> *spgrid)
-
inline NeighborhoodIterator(NeighborhoodVector indices, const SpacePointGrid<external_spacepoint_t> *spgrid, size_t curInd, sp_it_t curIt)
-
inline NeighborhoodIterator(const NeighborhoodIterator<external_spacepoint_t> &other)
-
inline bool operator!=(const NeighborhoodIterator<external_spacepoint_t> &other)
-
inline InternalSpacePoint<external_spacepoint_t> *operator*()
-
inline void operator++()
Public Members
-
sp_it_t m_binEnd
-
size_t m_curInd
-
sp_it_t m_curIt
-
const Acts::SpacePointGrid<external_spacepoint_t> *m_grid
-
NeighborhoodVector m_indices
Public Static Functions
-
static inline NeighborhoodIterator<external_spacepoint_t> begin(NeighborhoodVector indices, const SpacePointGrid<external_spacepoint_t> *spgrid)
-
using sp_it_t = typename std::vector<std::unique_ptr<InternalSpacePoint<external_spacepoint_t>>>::const_iterator
-
struct Neutral
- #include <Acts/EventData/Charge.hpp>
Charge and momentum interpretation for neutral particles.
Public Functions
-
Neutral() = default
-
template<typename T>
inline constexpr Neutral(T absQ) noexcept Construct and verify the input charge magnitude (in debug builds).
This constructor is only provided to allow consistent construction.
-
Neutral() = default
-
class NullBField : public Acts::MagneticFieldProvider
- #include <Acts/MagneticField/NullBField.hpp>
Null bfield which returns 0 always.
Public Functions
-
NullBField() = default
Default constructor.
-
inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value at a given location.
Requires a cache object created through makeCache().
Note
The
position
is ignored and only kept as argument to provide a consistent interface with other magnetic field services.- Parameters
position – [in] global 3D position for the lookup
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector at given position
-
inline virtual Result<Vector3> getFieldGradient(const Vector3 &position, ActsMatrix<3, 3> &derivative, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value its its gradient.
Requires a cache object created through makeCache().
Note
The
position
is ignored and only kept as argument to provide a consistent interface with other magnetic field services.Note
currently the derivative is not calculated
- Parameters
position – [in] global 3D position
derivative – [out] gradient of magnetic field vector as (3x3) matrix
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector
-
inline bool isInside(const Vector3 &position) const
check whether given 3D position is inside look-up domain
Note
The method will always return true for the null B-Field
- Parameters
position – [in] global 3D position
- Returns
true
if position is inside the defined look-up grid, otherwisefalse
-
inline virtual Acts::MagneticFieldProvider::Cache makeCache(const Acts::MagneticFieldContext &mctx) const override
Make an opaque cache for the magnetic field.
Instructs the specific implementation to generate a
Cache
instance for magnetic field lookup.- Parameters
mctx – The magnetic field context to generate cache for
- Returns
Cache The opaque cache object
-
struct Cache
- #include <Acts/MagneticField/NullBField.hpp>
Public Functions
-
inline Cache(const MagneticFieldContext&)
constructor with context
-
inline Cache(const MagneticFieldContext&)
-
NullBField() = default
-
template<typename object_t, typename representation_t = object_t>
class ObjectIntersection - #include <Acts/Utilities/Intersection.hpp>
class extensions to return also the object and a representation
Public Functions
-
ObjectIntersection() = default
Default constructor.
-
template<typename T = representation_t, std::enable_if_t<std::is_same<T, object_t>::value, int> = 0>
inline ObjectIntersection(const Intersection3D &sInter, const object_t *sObject) Object intersection - symmetric setup.
- Parameters
sInter – is the intersection
sObject – is the object to be instersected
-
inline ObjectIntersection(const Intersection3D &sInter, const object_t *sObject, const representation_t *sRepresentation)
Object intersection.
- Parameters
sInter – is the intersection
sObject – is the object to be instersected
sRepresentation – is the object represenatation
-
inline explicit operator bool() const
Bool() operator for validity checking.
-
inline bool operator<(const ObjectIntersection<object_t, representation_t> &oi) const
Smaller operator for ordering & sorting.
This operator will ignore the alternative, but simply order the representing intersection
- Parameters
oi – is the source intersection for comparison
-
inline bool operator>(const ObjectIntersection<object_t, representation_t> &oi) const
Greater operator for ordering & sorting.
This operator will ignore the alternative, but simply order the representing intersection
- Parameters
oi – is the source intersection for comparison
Public Members
-
Intersection3D alternative = {}
The alternative intersections.
-
Intersection3D intersection = {}
The intersection itself.
-
const object_t *object = {nullptr}
The object that was (tried to be) intersected.
-
const representation_t *representation = {nullptr}
The representation of this object.
-
ObjectIntersection() = default
-
template<class T>
class ObjectSorterT - #include <Acts/Geometry/GeometryObjectSorter.hpp>
Public Functions
-
inline ObjectSorterT(BinningValue bValue)
Constructor from a binning value.
- Parameters
bValue – is the value in which the binning is done
-
inline BinningValue binningValue() const
-
inline ObjectSorterT(BinningValue bValue)
-
template<typename T = double>
class ObjVisualization3D : public Acts::IVisualization3D - #include <Acts/Visualization/ObjVisualization3D.hpp>
This helper produces output in the OBJ format.
Note that colors are not supported in this implementation.
Public Types
-
using LineType = std::pair<size_t, size_t>
Type of a line.
-
using ValueType = T
Stored value type, should be double or float.
-
using VertexType = Eigen::Matrix<ValueType, 3, 1>
Type of a vertex based on the value type.
Public Functions
-
inline ObjVisualization3D(unsigned int prec = 4, double scale = 1.)
Constructor that allows to set scalor and precision.
- Parameters
prec – The output precission with std::setprecision
scale – An (optional) scaling for the writing out
-
virtual void clear() final
Remove all contents of this helper.
-
virtual void face(const std::vector<Vector3> &vtxs, ColorRGB color = {0, 0, 0}) final
Draw a face that connects a list of vertices.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the face
color – The color of the face
-
virtual void faces(const std::vector<Vector3> &vtxs, const std::vector<FaceType> &faces, ColorRGB color = {0, 0, 0}) final
Draw a faces that connects a list of vertices - expert only.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the faceS
faces – The face presectiotions (i.e. connecting vertices)
color – The color of the face
-
virtual void line(const Vector3 &a, const Vector3 &b, ColorRGB color = {0, 0, 0}) final
Draw a line from a vertex to another.
- Parameters
a – The start vertex
b – The end vertex
color – The color of the line
-
virtual void vertex(const Vector3 &vtx, ColorRGB color = {0, 0, 0}) final
Draw a vertex at a given location and a color.
- Parameters
vtx – The vertex position
color – The color
-
virtual void write(const std::string &path) const final
Write the content of the helper to an outstream.
Note
wil change to std::filesystem::path once gcc9 is standard
- Parameters
path – is the file system path for writing the file
-
virtual void write(std::ostream &os) const final
Write the content of the helper to an outstream.
- Parameters
os – The output stream for file
-
void write(std::ostream &os, std::ostream &mos) const
Write the object and the material file.
- Parameters
os – the output stream for the object
mos – the output stream for the auxiliary material file
-
using LineType = std::pair<size_t, size_t>
-
class OnnxRuntimeBase
- #include </home/docs/checkouts/readthedocs.org/user_builds/acts/checkouts/v20.2.0/Plugins/Onnx/include/Acts/Plugins/Onnx/OnnxRuntimeBase.hpp>
Subclassed by Acts::MLTrackClassifier
Public Functions
-
OnnxRuntimeBase() = default
Default constructor.
-
OnnxRuntimeBase(Ort::Env &env, const char *modelPath)
Parametrized constructor.
- Parameters
env – the ONNX runtime environment
modelPath – the path to the ML model in *.onnx format
-
~OnnxRuntimeBase() = default
Default destructor.
-
OnnxRuntimeBase() = default
-
struct ParticleStopped
- #include <Acts/Propagator/StandardAborters.hpp>
If the particle stopped (p=0) abort the propagation.
Public Functions
-
ParticleStopped() = default
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] The stepper object
-
ParticleStopped() = default
-
class PassiveLayerBuilder : public Acts::ILayerBuilder
- #include <Acts/Geometry/PassiveLayerBuilder.hpp>
The PassiveLayerBuilder is able to build cylinder & disc layers with given dimensions and material.
The specifications of the layers have to be given by the configuration struct.
Public Functions
-
PassiveLayerBuilder(const Config &plConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("PassiveLayerBuilder", Logging::INFO))
Constructor.
- Parameters
plConfig – is the ocnfiguration struct that steers behavior
logger – logging instance
-
~PassiveLayerBuilder() override = default
Destructor.
-
virtual const LayerVector centralLayers(const GeometryContext &gctx) const override
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at the central sector
-
inline Config getConfiguration() const
Get configuration method.
-
inline virtual const std::string &identification() const override
Name identification.
- Returns
the string based identification
-
virtual const LayerVector negativeLayers(const GeometryContext &gctx) const override
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at negative side
-
virtual const LayerVector positiveLayers(const GeometryContext &gctx) const override
LayerBuilder interface method.
- Parameters
gctx – ist the geometry context under which the geometry is built
- Returns
the layers at positive side
-
void setConfiguration(const Config &plConfig)
Set configuration method.
- Parameters
plConfig – is a configuration struct it overwrites the current configuration
-
void setLogger(std::unique_ptr<const Logger> newLogger)
Set logging instance.
- Parameters
newLogger – the logger instance
-
struct Config
- #include <Acts/Geometry/PassiveLayerBuilder.hpp>
Configuration struct for the passive layer builder This nested struct is used to configure the layer building.
Public Members
-
std::vector<double> centralLayerHalflengthZ
central layer specs
-
std::vector<std::shared_ptr<const ISurfaceMaterial>> centralLayerMaterial
central layer specs
-
std::vector<double> centralLayerRadii
central layer specs
-
std::vector<double> centralLayerThickness
central layer specs
-
std::string layerIdentification
string based identification
-
std::vector<std::shared_ptr<const ISurfaceMaterial>> posnegLayerMaterial
p/n layer specs
-
std::vector<double> posnegLayerPositionZ
p/n layer specs
-
std::vector<double> posnegLayerRmax
p/n layer specs
-
std::vector<double> posnegLayerRmin
p/n layer specs
-
std::vector<double> posnegLayerThickness
p/n layer specs
-
std::vector<double> centralLayerHalflengthZ
-
PassiveLayerBuilder(const Config &plConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("PassiveLayerBuilder", Logging::INFO))
-
struct PathLimitReached
- #include <Acts/Propagator/StandardAborters.hpp>
This is the condition that the pathLimit has been reached.
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] Stepper used for propagation
Public Members
-
double internalLimit = std::numeric_limits<double>::max()
Boolean switch for Loop protection.
-
template<typename propagator_state_t, typename stepper_t>
-
class PerigeeSurface : public Acts::LineSurface
- #include <Acts/Surfaces/PerigeeSurface.hpp>
Class describing the Line to which the Perigee refers to.
The Surface axis is fixed to be the z-axis of the Tracking frame. It inherits from StraingLineSurface.
Public Functions
-
PerigeeSurface() = delete
Default Constructor - deleted.
-
~PerigeeSurface() override = default
Destructor - defaulted.
-
virtual std::string name() const final
Return properly formatted class name for screen output */.
-
PerigeeSurface &operator=(const PerigeeSurface &other)
Assignment operator.
- Parameters
other – is the source surface to be assigned
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const final
Return a Polyhedron for the surfaces.
Note
ignored
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – is ignored for a perigee
- Returns
A list of vertices and a face/facett description of it
-
virtual std::ostream &toStream(const GeometryContext &gctx, std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
gctx – The current geometry context object, e.g. alignment
sl – is the ostream to be dumped into
- Returns
ostreamn obect which was streamed into
-
virtual SurfaceType type() const final
Return the surface type.
-
PerigeeSurface() = delete
-
class PlanarBounds : public Acts::SurfaceBounds
- #include <Acts/Surfaces/PlanarBounds.hpp>
common base class for all bounds that are in a local x/y cartesian frame
simply introduced to avoid wrong bound assigments to surfaces
Subclassed by Acts::ConvexPolygonBoundsBase, Acts::DiamondBounds, Acts::EllipseBounds, Acts::RectangleBounds, Acts::TrapezoidBounds
Public Functions
-
virtual const RectangleBounds &boundingBox() const = 0
Bounding box parameters.
- Returns
rectangle bounds for a bounding box
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const = 0
Return the vertices.
Note
that the extremas are given, which may slightly alter the number of segments returned
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
class PlanarModuleCluster : public Acts::Measurement<BoundIndices, 3>
- #include <Acts/Digitization/PlanarModuleCluster.hpp>
Public Functions
Constructor from DigitizationCells.
- Parameters
surface – [in] The surface the cluster is on
sourceLink – [in] is the link to the truth information
cov – [in] is the covariance matrix
loc0 – [in] is the local position in the first coordinate
loc1 – [in] is the local position in the second coordinate
t – [in] Timestamp of the cluster
dCells – [in] is the vector of digitization cells
dModule – [in] an optional pointer to a digitization configuration
-
inline const std::vector<DigitizationCell> &digitizationCells() const
access to the digitization cells
- Returns
the vector to the digitization cells
-
inline const DigitizationModule *digitizationModule() const
access to the digitization module
- Returns
the pointer to the digitization module
-
inline const Surface &referenceObject() const
Module surface.
-
class PlanarModuleStepper
- #include <Acts/Digitization/PlanarModuleStepper.hpp>
Module for fast, geometric digitization this is a planar module stepper that calculates the step length in given segmentations and retrunes digitisation steps.
Public Functions
-
PlanarModuleStepper(std::unique_ptr<const Logger> mlogger = getDefaultLogger("PlanarModuleStepper", Logging::INFO))
Constructor.
- Parameters
mlogger – is the logging istance
-
~PlanarModuleStepper() = default
Destructor.
-
std::vector<DigitizationStep> cellSteps(const GeometryContext &gctx, const DigitizationModule &dmodule, const Vector3 &startPoint, const Vector3 &endPoint) const
Calculate the steps caused by this track - full simulation interface.
- Parameters
gctx – The current geometry context object, e.g. alignment
dmodule – is the digitization module
startPoint – is the starting position of the stepping
endPoint – is the end postion of the stepping
- Returns
is the vector of digitization steps
-
std::vector<DigitizationStep> cellSteps(const GeometryContext &gctx, const DigitizationModule &dmodule, const Vector2 &moduleIntersection, const Vector3 &trackDirection) const
Calculate the steps caused by this track - fast simulation interface.
- Parameters
gctx – The current geometry context object, e.g. alignment
dmodule – is the digitization module
moduleIntersection – is the 2d intersection at the module surface
trackDirection – is the track direction at the instersection
- Returns
is the vector of digitization steps
-
inline void setLogger(std::unique_ptr<const Logger> logger)
Set logging instance.
- Parameters
logger – is the logging instance to be set
-
PlanarModuleStepper(std::unique_ptr<const Logger> mlogger = getDefaultLogger("PlanarModuleStepper", Logging::INFO))
-
class PlaneLayer : public virtual Acts::PlaneSurface, public Acts::Layer
- #include <Acts/Geometry/PlaneLayer.hpp>
Class to describe a planar detector layer for tracking, it inhertis from both, Layer base class and PlaneSurface class.
Public Functions
-
PlaneLayer() = delete
-
PlaneLayer(const PlaneLayer &pla) = delete
-
~PlaneLayer() override = default
-
PlaneLayer &operator=(const PlaneLayer&) = delete
-
virtual const PlaneSurface &surfaceRepresentation() const override
Transforms the layer into a Surface representation for extrapolation.
- Returns
returns a reference to a PlaneSurface
-
virtual PlaneSurface &surfaceRepresentation() override
Public Static Functions
Factory for a shared plane layer.
- Parameters
transform – which places the layer in the global frame
pbounds – the planar bounds that define the layer dimensions
surfaceArray – is the surface array that holds the sensitive surfaces
thickness – is the thickness of the layer (normal direction to plane)
ad – is the approach descriptor for describing the approach surface
laytyp – is the layer type
- Returns
shared pointer to a PlaneLayer
-
PlaneLayer() = delete
-
class PlaneSurface : public Acts::Surface
- #include <Acts/Surfaces/PlaneSurface.hpp>
Class for a planaer in the TrackingGeometry.
The PlaneSurface extends the Surface class with the possibility to convert local to global positions (vice versa).
Subclassed by Acts::PlaneLayer
Public Functions
-
PlaneSurface() = delete
-
~PlaneSurface() override = default
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const final
The binning position is the position calcualted for a certain binning type.
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the binning type to be used
- Returns
position that can beused for this binning
-
virtual const SurfaceBounds &bounds() const override
Return method for bounds object of this surfrace.
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const override
Global to local transformation For planar surfaces the momentum is ignroed in the global to local transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
momentum – global 3D momentum representation (optionally ignored) method symmetry)
tolerance – optional tolerance within which a point is considered valid on surface
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck = false) const final
Straight line intersection.
mathematical motivation:
the equation of the plane is given by: \( \vec n \cdot \vec x = \vec n \cdot \vec p,\) where \( \vec n = (n_{x}, n_{y}, n_{z})\) denotes the normal vector of the plane, \( \vec p = (p_{x}, p_{y}, p_{z})\) one specific point on the plane and \( \vec x = (x,y,z) \) all possible points on the plane.
Given a line with:\( \vec l(u) = \vec l_{1} + u \cdot \vec v \)
,
the solution for
\( u \) can be written: \( u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}\) If the denominator is 0 then the line lies:either in the plane
perpendicular to the normal of the plane
Note
expected to be normalized)
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The start position of the intersection attempt
direction – The direction of the interesection attempt, (
bcheck – The boundary check directive
- Returns
the SurfaceIntersection object
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const override
Local to global transformation For planar surfaces the momentum is ignroed in the local to global transformation.
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – local 2D position in specialized surface frame
momentum – global 3D momentum representation (optionally ignored)
- Returns
the global position by value
-
virtual std::string name() const override
Return properly formatted class name for screen output.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final
Normal vector return.
return a Vector3 by value
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position is ignored
-
PlaneSurface &operator=(const PlaneSurface &other)
Assignment operator.
- Parameters
other – The source PlaneSurface for assignment
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final
Method that calculates the correction due to incident angle.
Note
this is the final implementation of the pathCorrection function
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
direction – global 3D momentum direction (ignored for PlaneSurface)
- Returns
a double representing the scaling factor
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const override
Return a Polyhedron for the surfaces.
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, it represents the full 2*M_PI coverange, if lseg is set to 1 only the extrema are given
- Returns
A list of vertices and a face/facett description of it
-
virtual SurfaceType type() const override
Return the surface type.
-
PlaneSurface() = delete
-
template<typename T = double>
class PlyVisualization3D : public Acts::IVisualization3D - #include <Acts/Visualization/PlyVisualization3D.hpp>
Helper to write out PlyVisualization3D visualization format.
Public Types
-
using ValueType = T
Stored value type, should be double or float.
-
using VertexType = Eigen::Matrix<ValueType, 3, 1>
Type of a vertex based on the value type.
Public Functions
-
virtual void clear() final
Remove all contents of this helper.
-
virtual void face(const std::vector<Vector3> &vtxs, ColorRGB color = {120, 120, 120}) final
Draw a face that connects a list of vertices.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the face
color – The color of the face
-
virtual void faces(const std::vector<Vector3> &vtxs, const std::vector<FaceType> &faces, ColorRGB color = {120, 120, 120}) final
Draw a faces that connects a list of vertices - expert only.
Note
Depending on the helper implementation, out of plane vertices might be handled differently.
- Parameters
vtxs – The vertices that make up the faceS
faces – The face presectiotions (i.e. connecting vertices)
color – The color of the face
-
virtual void line(const Vector3 &a, const Vector3 &b, ColorRGB color = {120, 120, 120}) final
Draw a line from a vertex to another.
- Parameters
a – The start vertex
b – The end vertex
color – The color of the line
-
virtual void vertex(const Vector3 &vtx, ColorRGB color = {120, 120, 120}) final
Draw a vertex at a given location and a color.
- Parameters
vtx – The vertex position
color – The color
-
virtual void write(const std::string &path) const final
Write the content of the helper to an outstream.
Note
wil change to std::filesystem::path once gcc9 is standard
- Parameters
path – is the file system path for writing the file
-
virtual void write(std::ostream &os) const final
Write the content of the helper to an outstream.
- Parameters
os – The output stream for file
-
using ValueType = T
-
class Polyhedron
- #include <Acts/Geometry/Polyhedron.hpp>
Struct which contains a cartesian approximation for any surface type.
It contains a list of cartesian vertices in the global frame, and additionally a list of lists of indices which indicate which vertices form a face. Each entry in
faces
is a face, which is in turn a list of vertices that need to be connected to form a face. This allows theobjString
method to produce a ready-to-go obj output.Public Types
-
using FaceType = std::vector<size_t>
Public Functions
-
Polyhedron() = default
Default constructor.
-
inline Polyhedron(const std::vector<Vector3> &verticesIn, const std::vector<FaceType> &facesIn, const std::vector<FaceType> &triangularMeshIn, bool isExact = true)
Default constructor from a vector of vertices and a vector of faces.
Note
This creates copies of the input vectors
- Parameters
verticesIn – The 3D global vertices that make up the object
facesIn – List of lists of indices for faces.
triangularMeshIn – List of lists of indices for a triangular mesh
isExact – A dedicated flag if this is exact or not
-
Extent extent(const Transform3 &transform = Transform3::Identity()) const
Maximum extent of the polyhedron in space.
- Parameters
transform – An (optional) transform to apply to the vertices for estimation the extent with respect to a given coordinate frame
- Returns
ranges that describe the space taken by this surface
-
void merge(const Polyhedron &other)
Merge another Polyhedron into this one.
- Parameters
other – is the source representation
-
void move(const Transform3 &transform)
Move the polyhedron with a Transfrom3D.
- Parameters
transform – The additional transform applied
Public Members
-
bool exact = true
Is this an exact representation (approximating curved spaces)
-
std::vector<FaceType> faces
List of faces connecting the vertices.
each face is a list of vertices v corresponding to the vertex vector above
-
std::vector<FaceType> triangularMesh
List of faces connecting the vertices.
each face is a list of vertices v
in this case restricted to a triangular representation
-
std::vector<Vector3> vertices
List of 3D vertices as vectors.
-
using FaceType = std::vector<size_t>
-
template<typename stepper_t, typename navigator_t = detail::VoidNavigator>
class Propagator - #include <Acts/Propagator/Propagator.hpp>
Propagator for particles (optionally in a magnetic field)
The Propagator works with a state objects given at function call This state object contains the thread local state objects
Navigator::state_type for object navigation and screen output
Stepper::state_type state for the actual transport caching (pos,dir,field)
This Propagator class serves as high-level steering code for propagating track parameters. The actual implementation of the propagation has to be implemented in the stepper_t object, which has to provide the following:
a function for performing a single propagation step
a type mapping for: initial track parameter type -> type of final track parameters
a type mapping for: (initial track parameter type and destination surface type) -> type of final track parameters
a type mapping for: initial track parameter type -> type of internal state object
a type mapping for: (initial track parameter type and destination surface type) -> type of internal state object
- Template Parameters
stepper_t – Type of stepper implementation of the propagation
naviagor_t – Type of the navigator (optional)
Public Types
-
using action_list_t_result_t = typename result_type_helper<parameters_t, action_list_t>::type
Short-hand type definition for propagation result derived from an action list.
- Template Parameters
parameters_t – Type of the final track parameters
action_list_t – List of propagation action types
Type of the navigator in use for public scope.
Typedef the navigator state.
-
using Stepper = stepper_t
Type of the stepper in use for public scope.
-
using StepperState = typename Stepper::State
Type of state object used by the propagation implementation.
Public Functions
Constructor from implementation object.
- Parameters
stepper – The stepper implementation is moved to a private member
navigator – The navigator implementation, moved to a private member
-
template<typename parameters_t, typename propagator_options_t, typename path_aborter_t = PathLimitReached>
Result<action_list_t_result_t<CurvilinearTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const propagator_options_t &options) const Propagate track parameters.
This function performs the propagation of the track parameters using the internal stepper implementation, until at least one abort condition is fulfilled or the maximum number of steps/path length provided in the propagation options is reached.
- Template Parameters
parameters_t – Type of initial track parameters to propagate
propagator_options_t – Type of the propagator options
path_aborter_t – The path aborter type to be added
- Parameters
start – [in] initial track parameters to propagate
options – [in] Propagation options, type Options<,>
- Returns
Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)
-
template<typename parameters_t, typename propagator_options_t, typename path_aborter_t = PathLimitReached>
Result<action_list_t_result_t<CurvilinearTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const propagator_options_t &options, action_list_t_result_t<CurvilinearTrackParameters, typename propagator_options_t::action_list_type> &&inputResult) const Propagate track parameters.
This function performs the propagation of the track parameters using the internal stepper implementation, until at least one abort condition is fulfilled or the maximum number of steps/path length provided in the propagation options is reached.
- Template Parameters
parameters_t – Type of initial track parameters to propagate
propagator_options_t – Type of the propagator options
path_aborter_t – The path aborter type to be added
- Parameters
start – [in] initial track parameters to propagate
options – [in] Propagation options, type Options<,>
inputResult – [in] an existing result object to start from
- Returns
Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)
-
template<typename parameters_t, typename propagator_options_t, typename target_aborter_t = SurfaceReached, typename path_aborter_t = PathLimitReached>
Result<action_list_t_result_t<BoundTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const Surface &target, const propagator_options_t &options) const Propagate track parameters - User method.
This function performs the propagation of the track parameters according to the internal implementation object until at least one abort condition is fulfilled, the destination surface is hit or the maximum number of steps/path length as given in the propagation options is reached.
- Template Parameters
parameters_t – Type of initial track parameters to propagate
propagator_options_t – Type of the propagator options
target_aborter_t – The target aborter type to be added
path_aborter_t – The path aborter type to be added
- Parameters
start – [in] Initial track parameters to propagate
target – [in] Target surface of to propagate to
options – [in] Propagation options
- Returns
Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)
-
template<typename parameters_t, typename propagator_options_t, typename target_aborter_t = SurfaceReached, typename path_aborter_t = PathLimitReached>
Result<action_list_t_result_t<BoundTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const Surface &target, const propagator_options_t &options, action_list_t_result_t<BoundTrackParameters, typename propagator_options_t::action_list_type> inputResult) const Propagate track parameters - User method.
This function performs the propagation of the track parameters according to the internal implementation object until at least one abort condition is fulfilled, the destination surface is hit or the maximum number of steps/path length as given in the propagation options is reached.
- Template Parameters
parameters_t – Type of initial track parameters to propagate
propagator_options_t – Type of the propagator options
target_aborter_t – The target aborter type to be added
path_aborter_t – The path aborter type to be added
- Parameters
start – [in] Initial track parameters to propagate
target – [in] Target surface of to propagate to
options – [in] Propagation options
inputResult – [in] an existing result object to start from
- Returns
Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)
-
template<typename propagator_options_t>
struct State - #include <Acts/Propagator/Propagator.hpp>
private Propagator state for navigation and debugging
This struct holds the common state information for propagating which is independent of the actual stepper implementation.
- Template Parameters
parameters_t – Type of the track parameters
propagator_options_t – Type of the Objections object
Public Functions
-
template<typename parameters_t>
inline State(const parameters_t &start, const propagator_options_t &topts, StepperState steppingIn) Create the propagator state from the options.
- Template Parameters
parameters_t – the type of the start parameters
propagator_options_t – the type of the propagator options
- Parameters
start – The start parameters, used to initialize stepping state
topts – The options handed over by the propagate call
steppingIn – Stepper state instance to begin with
Public Members
-
std::reference_wrapper<const GeometryContext> geoContext
Context object for the geometry.
Navigation state - internal state of the Navigator.
-
propagator_options_t options
These are the options - provided for each propagation step.
-
StepperState stepping
Stepper state - internal state of the Stepper.
-
template<typename action_list_t = ActionList<>, typename aborter_list_t = AbortList<>>
struct PropagatorOptions : public Acts::PropagatorPlainOptions - #include <Acts/Propagator/Propagator.hpp>
Options for propagate() call.
- Template Parameters
action_list_t – List of action types called after each propagation step with the current propagation and stepper state
aborter_list_t – List of abort conditions tested after each propagation step using the current propagation and stepper state
Subclassed by Acts::DenseStepperPropagatorOptions< action_list_t, aborter_list_t >
Public Functions
-
PropagatorOptions() = delete
Delete default contructor.
-
PropagatorOptions(const PropagatorOptions<action_list_t, aborter_list_t> &po) = default
PropagatorOptions copy constructor.
-
inline PropagatorOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, LoggerWrapper logger_)
PropagatorOptions with context.
-
template<typename extended_aborter_list_t>
inline PropagatorOptions<action_list_t, extended_aborter_list_t> extend(extended_aborter_list_t aborters) const Expand the Options with extended aborters.
- Template Parameters
extended_aborter_list_t – Type of the new aborter list
- Parameters
aborters – The new aborter list to be used (internally)
-
inline void setPlainOptions(const PropagatorPlainOptions &pOptions)
Set the plain options.
- Parameters
pOptions – The plain options
Public Members
-
aborter_list_t abortList
List of abort conditions.
-
action_list_t actionList
List of actions.
-
std::reference_wrapper<const GeometryContext> geoContext
The context object for the geometry.
-
LoggerWrapper logger
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
The context object for the magnetic field.
-
struct PropagatorPlainOptions
- #include <Acts/Propagator/Propagator.hpp>
Class holding the trivial options in propagator options.
Subclassed by Acts::PropagatorOptions< action_list_t, aborter_list_t >
Public Members
-
int absPdgCode = 211
The |pdg| code for (eventual) material integration - pion default.
-
NavigationDirection direction = NavigationDirection::Forward
Propagation direction.
-
double loopFraction = 0.5
Allowed loop fraction, 1 is a full loop.
-
bool loopProtection = true
Loop protection step, it adapts the pathLimit.
-
double mass = 139.57018 * UnitConstants::MeV
The mass for the particle for (eventual) material integration.
-
unsigned int maxRungeKuttaStepTrials = 10000
Maximum number of Runge-Kutta steps for the stepper step call.
-
unsigned int maxSteps = 1000
Maximum number of steps for one propagate call.
-
double maxStepSize = std::numeric_limits<double>::max()
Absolute maximum step size.
-
double pathLimit = std::numeric_limits<double>::max()
Absolute maximum path length.
-
double stepSizeCutOff = 0.
Cut-off value for the step size.
-
double targetTolerance = s_onSurfaceTolerance
Required tolerance to reach target (surface, pathlength)
-
double tolerance = 1e-4
Tolerance for the error of the integration.
-
int absPdgCode = 211
-
template<typename parameters_t, typename ...result_list>
struct PropagatorResult : private detail::Extendable<result_list...> - #include <Acts/Propagator/Propagator.hpp>
Simple class holding result of propagation call.
- Template Parameters
parameters_t – Type of final track parameters
result_list – Result pack for additional propagation quantities
Public Members
-
std::unique_ptr<parameters_t> endParameters = nullptr
Final track parameters - initialized to null pointer.
-
double pathLength = 0.
Signed distance over which the parameters were propagated.
-
unsigned int steps = 0
Number of propagation steps that were carried out.
-
std::unique_ptr<BoundMatrix> transportJacobian = nullptr
Full transport jacobian.
-
struct ProtoLayer
- #include <Acts/Geometry/ProtoLayer.hpp>
Encapsulates min/max boundaries that will be turned into a layer.
The struct allows this information to be obtained in a consistent way, or be caller provided.
Public Types
-
using Range = std::pair<double, double>
The envelope parameters.
Public Functions
-
ProtoLayer(const GeometryContext &gctx, const std::vector<const Surface*> &surfaces)
Constructor.
Loops over a provided vector of surface and calculates the various min/max values in one go. Also takes into account the thickness of an associated DetectorElement, if it exists.
- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – The vector of surfaces to consider
Constructor.
Loops over a provided vector of surface and calculates the various min/max values in one go. Also takes into account the thickness of an associated DetectorElement, if it exists.
- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – The vector of surfaces to consider
-
ProtoLayer() = default
-
void add(const GeometryContext &gctx, const Surface &surface)
Add a surface, this will also increase the extent.
- Parameters
gctx – The current geometry context object, e.g. alignment
surface – The surface which is added to the ProtoLayer
-
double max(BinningValue bval, bool addenv = true) const
- Parameters
bval – The accessed binning value
addenv – The steering if enevlope is added or not
-
double medium(BinningValue bval, bool addenv = true) const
- Parameters
bval – The accessed binning value
addenv – The steering if enevlope is added or not
-
double min(BinningValue bval, bool addenv = true) const
Get the parameters : min.
- Parameters
bval – The accessed binning value
addenv – The steering if enevlope is added or not
-
double range(BinningValue bval, bool addenv = true) const
- Parameters
bval – The accessed binning value
addenv – The steering if enevlope is added or not
-
inline const std::vector<const Surface*> &surfaces() const
Give access to the surfaces used/assigned to the ProtoLayer.
-
std::ostream &toStream(std::ostream &sl) const
Output to ostream.
- Parameters
sl – the input ostream
-
using Range = std::pair<double, double>
-
class ProtoLayerHelper
- #include <Acts/Geometry/ProtoLayerHelper.hpp>
This class is designed to parse a vector of Surfaces and sort them into corresponding proto layers.
Public Types
-
using SortingConfig = std::pair<BinningValue, double>
Public Functions
-
inline ProtoLayerHelper(const Config &config, std::unique_ptr<const Logger> logger = getDefaultLogger("ProtoLayerHelper", Logging::INFO))
Constructor with explicit config.
- Parameters
config – Explicit config struct
logger – logging instance
-
~ProtoLayerHelper() = default
-
std::vector<ProtoLayer> protoLayers(const GeometryContext &gctx, const std::vector<const Surface*> &surfaces, const SortingConfig &sorting) const
Sort the surfaces into ProtoLayers.
- Parameters
gctx – The geometry context (usually building context at this stage)
surfaces – The surfaces to be sorted into arrays
sorting – The sorting setup, one single sorting
- Returns
A vector of ProtoLayers
-
std::vector<ProtoLayer> protoLayers(const GeometryContext &gctx, const std::vector<const Surface*> &surfaces, const std::vector<SortingConfig> &sortings) const
Sort the surfaces into ProtoLayers, sequential sorting.
- Parameters
gctx – The geometry context (usually building context at this stage)
surfaces – The surfaces to be sorted into arrays
sortings – The sequential sorting setup
- Returns
A vector of ProtoLayers
-
struct Config
- #include <Acts/Geometry/ProtoLayerHelper.hpp>
-
using SortingConfig = std::pair<BinningValue, double>
-
class ProtoSurfaceMaterial : public Acts::ISurfaceMaterial
- #include <Acts/Material/ProtoSurfaceMaterial.hpp>
proxy to SurfaceMaterial hand over BinUtility
The ProtoSurfaceMaterial class acts as a proxy to the SurfaceMaterial to mark the layers and surfaces on which the material should be mapped on at construction time of the geometry and to hand over the granularity of of the material map with the bin Utility.
Public Functions
-
ProtoSurfaceMaterial() = default
Constructor without BinUtility - homogenous material.
-
ProtoSurfaceMaterial(const BinUtility &binUtility, MappingType mappingType = MappingType::Default)
Constructor with BinUtility - multidimensional material.
- Parameters
binUtility – a BinUtility determining the granularity and binning of the material on the surface/layer
mappingType – is the type of surface mapping associated to the surface
-
ProtoSurfaceMaterial(const ProtoSurfaceMaterial &smproxy) = default
Copy constuctor.
- Parameters
smproxy – The source proxy
-
ProtoSurfaceMaterial(ProtoSurfaceMaterial &&smproxy) = default
Copy move constuctor.
- Parameters
smproxy – The source proxy
-
~ProtoSurfaceMaterial() override = default
Destructor.
-
inline const BinUtility &binUtility() const
Return the BinUtility.
-
inline virtual const MaterialSlab &materialSlab(const Vector2 &lp) const final
Return method for full material description of the Surface - from local coordinates.
- Parameters
lp – is local positioning vector
- Returns
will return dummy material
-
inline virtual const MaterialSlab &materialSlab(const Vector3 &gp) const final
Return method for full material description of the Surface - from the global coordinates.
- Parameters
gp – is the global positioning vector
- Returns
will return dummy material
-
inline virtual const MaterialSlab &materialSlab(size_t ib0, size_t ib1) const final
Direct access via bins to the MaterialSlab.
- Parameters
ib0 – indicates the first bin
ib1 – indicates the seconf bin
- Returns
will return dummy material
-
virtual ProtoSurfaceMaterial &operator*=(double scale) final
Scale operator.
- Parameters
scale – The value to scale this material by
-
ProtoSurfaceMaterial &operator=(const ProtoSurfaceMaterial &smproxy) = default
Assignment operator.
- Parameters
smproxy – The source proxy
-
ProtoSurfaceMaterial &operator=(ProtoSurfaceMaterial &&smproxy) = default
Assigment move operator.
- Parameters
smproxy – The source proxy
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream, to be overloaded by child classes.
-
ProtoSurfaceMaterial() = default
-
class ProtoVolumeMaterial : public Acts::IVolumeMaterial
- #include <Acts/Material/ProtoVolumeMaterial.hpp>
proxy to VolumeMaterial hand over BinUtility
The ProtoVolumeMaterial class acts as a proxy to the VolumeMaterial to mark the volume on which the material should be mapped on at construction time of the geometry and to hand over the granularity of of the material map with the bin Utility.
Public Functions
-
ProtoVolumeMaterial() = default
Constructor without BinUtility - homogenous material.
-
ProtoVolumeMaterial(const BinUtility &binUtility)
Constructor with BinUtility - multidimensional material.
- Parameters
binUtility – a BinUtility determining the granularity and binning of the material on the volume
-
ProtoVolumeMaterial(const ProtoVolumeMaterial &vmproxy) = default
Copy constuctor.
- Parameters
vmproxy – The source proxy
-
ProtoVolumeMaterial(ProtoVolumeMaterial &&vmproxy) = default
Copy move constuctor.
- Parameters
vmproxy – The source proxy
-
~ProtoVolumeMaterial() override = default
Destructor.
-
inline const BinUtility &binUtility() const
Return the BinUtility.
Return the bin Utility.
-
ProtoVolumeMaterial &operator=(const ProtoVolumeMaterial &vmproxy) = default
Assignment operator.
- Parameters
vmproxy – The source proxy
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – The outoput stream
-
ProtoVolumeMaterial() = default
-
class RadialBounds : public Acts::DiscBounds
- #include <Acts/Surfaces/RadialBounds.hpp>
Class to describe the bounds for a planar DiscSurface.
By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.
Public Types
-
enum BoundValues
Values:
-
enumerator eMinR
-
enumerator eMaxR
-
enumerator eHalfPhiSector
-
enumerator eAveragePhi
-
enumerator eSize
-
enumerator eMinR
Public Functions
-
RadialBounds() = delete
-
inline RadialBounds(double minR, double maxR, double halfPhi = M_PI, double avgPhi = 0.) noexcept(false)
Constructor for full disc of symmetric disc around phi=0.
- Parameters
minR – The inner radius (0 for full disc)
maxR – The outer radius
halfPhi – The half opening angle (Pi for full angular coverage)
avgPhi – The average phi for the disc/ring sector
-
inline RadialBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor from array values.
- Parameters
values – The bound values
-
~RadialBounds() override = default
-
inline virtual double binningValuePhi() const final
Return a reference radius for binning.
-
inline virtual double binningValueR() const final
Return a reference radius for binning.
-
inline virtual bool coversFullAzimuth() const final
Returns true for full phi coverage.
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
For disc surfaces the local position in (r,phi) is checked.
- Parameters
lposition – local position to be checked
bcheck – boundary check directive
- Returns
is a boolean indicating the operation success
-
inline virtual bool insideRadialBounds(double R, double tolerance = 0.) const final
Checks if this is inside the radial coverage given the a tolerance.
-
inline virtual double rMax() const final
Return method for outer Radius.
-
inline virtual double rMin() const final
Return method for inner Radius.
-
virtual std::ostream &toStream(std::ostream &sl) const final
Outstream operator.
- Parameters
sl – is the ostream to be dumped into
-
virtual SurfaceBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
enum BoundValues
-
template<typename Type>
class Range1D - #include <Acts/Utilities/Range1D.hpp>
A one-dimensional range between two points.
This type describes a one-demensional range of values, designed to be used in the construction of more complex multi-dimensional types. The class provides functionality for growing and shrinking the range, as well as some other utilities. These ranges are half-open, including the minimum but excluding the maximum.
- Template Parameters
Type – The scalar type of the values contained in this range.
Public Functions
-
inline Range1D()
Construct a new degenerate range object.
This constructor coonstructs a degenerate range object with a maximum lower than the minimum. In other words, this range is empty.
-
inline Range1D(Type min, Type max)
Construct a new range object from a lower and upper bound.
Construct a new range object given the values for the minimum and maximum. Note that it is perfectly possible to construct a degenerate range in this way.
- Parameters
min – The minimum value in the range (inclusive)
max – The maximum value in the range (exclusive)
-
inline Range1D(const std::pair<Type, Type> &p)
Construct a new range object from a pair of bounds.
Construct a new range object from a pair of values, the first of which is taken to be the minimum, and the second of which is taken to be the maximum.
- Parameters
p – The pair of values to use as the minimum and maximum
-
inline Range1D(const Range1D<Type> &o)
Construct a new range object from an existing range.
This simply copies the values from the existing range to the new one. It’s the copy constructor.
- Parameters
o – The range to copy
-
inline bool contains(const Type &v) const
Determine if the range contains a given value.
A value is inside a range if and only if it is greater than the minimum and smaller than the maximum.
- Parameters
v – The value to check
- Returns
true The value is inside the range
- Returns
false The value is not inside the range
-
inline bool degenerate(void) const
Determine if this range is degenerate or not.
A degenerate range has a minimum higher than the maximum, and thus cannot contain any values.
- Returns
true The range is degenerate and has size zero
- Returns
false The range is not degenerate
-
inline void expand(const Type &min, const Type &max)
Expand a range on both ends.
Expand a range by decreasing the minimum value as well as increasing the maximum value. If either of the values are already larger or smaller (respectively) than the proposed values, then that particular boundary of the interval is not expanded.
Note
After this operation, the range is always equal to or larger than [min, max].
- Parameters
min – The proposed new minimum for the range
max – The proposed new maximum for the range
-
inline void expandMax(const Type &v)
Expand a range by increasing the maximum value.
Expand the range by increasing the maximum value. If the given value is smaller than the current maximum (in other words, if the proposed new range would be smaller than the current range), this is a no-op.
- Parameters
v – The proposed new maximum for the range
-
inline void expandMin(const Type &v)
Expand a range by decreasing the minimum value.
Expand the range by decreasing the minimum value. If the given value is larger than the current minimum (in other words, if the proposed new range would be smaller than the current range), this is a no-op.
- Parameters
v – The proposed new minimum for the range
-
inline Type max(void) const
Return the maximum value of the range (inclusive)
-
inline Type min(void) const
Return the minimum value of the range (inclusive)
-
inline Range1D<Type> operator&(const Range1D<Type> &o) const
Compute the intersection of two ranges.
The intersection of two ranges is the range containing all values contained in both ranges. If the two ranges do not intersect, the intersection is a degenerate range. This operation is commutative.
- Parameters
o – The range to compute the intersection with
- Returns
The intersection range between the two ranges
-
inline bool operator&&(const Range1D<Type> &o) const
Determine whether the range intersects another range.
The intersection of a range is the space where both ranges overlap. If the ranges overlap at all, they are said to intersect. This operation is commutative.
- Parameters
o – The other range to check
- Returns
true The ranges intersect
- Returns
false The ranges do not intersect
-
inline Range1D<Type> &operator&=(const Range1D<Type> &o)
Set the range to the intersection of itself and another range.
This is an assignment version of operator&, which updates the range on which it is called to ensure that the new range is the intersection of the old range and the new range.
- Parameters
o – The range to compute the intersection with
- Returns
This object
-
inline bool operator<=(const Range1D<Type> &o) const
Determine whether the left-hand range is a subset of the right-hand range.
A range is a subset of another range if and only if all values contained in the first range are also contained in the second range.
- Parameters
o – The other range to check
- Returns
true The left-hand range is a subset of the right-hand range
- Returns
false The left-hand range is not a subset of the right-hand range
-
inline Range1D<Type> &operator=(const Range1D<Type> &o)
Assignment operator.
Copy the right-hand range into the left-hand range, which means setting the minimum and maximum to equal the minimum and maximum of the right-hand side.
- Parameters
o – The range of values to copy
- Returns
This range
-
inline bool operator==(const Range1D<Type> &o) const
Determine whether the range is equal to another range.
Two ranges are equal if and only if their minima and maxima are the same.
Warning
This method relies on the existence of a well-defined notion of equality for the underlying types. Using this method on floating ranges may have unintended effecrs.
- Parameters
o – The other range to check
- Returns
true The ranges are equal
- Returns
false The ranges are not equal
-
inline bool operator>=(const Range1D<Type> &o) const
Determine whether the left-hand range is a superset of the right-hand range.
A range is a superset of another range if and only if all values contained in the second range are also contained in the first range.
- Parameters
o – The other range to check
- Returns
true The left-hand range is a superset of thr right-hand range
- Returns
false The left-hand range is not a superset of the right-hand range
-
inline void set(const Type &min, const Type &max)
Set the minimum and maximum value.
Override both the minimum and maximum value of the range, regardless of what they were set to.
Note
If you want to shrink or expand the range, use the shrink and expand methods.
Note
After this operation, the range should be exactly equal to [min, max]
- Parameters
min – The new minimum value of the range
max – The new maximum value of the range
-
inline void setMax(const Type &v)
Set the maximum value.
Override the maximum value of the range, regardless of what was already set.
Note
If you want to shrink or expand the range, use the shrink and expand methods.
- Parameters
v – The value to use as the new maximum
-
inline void setMin(const Type &v)
Set the minimum value.
Override the minimum value of the range, regardless of what was already set.
Note
If you want to shrink or expand the range, use the shrink and expand methods.
- Parameters
v – The value to use as the new minimum
-
inline void shrink(const Type &min, const Type &max)
Shrink a range on both ends.
Shrink a range by increasing the minimum value as well as decreasing the maximum value. If either of the values are already smaller or larger (respectively) than the proposed values, then that particular boundary of the interval is not shrunk.
Note
After this operation, the range is always equal to or smaller than [min, max].
- Parameters
min – The proposed new minimum for the range
max – The proposed new maximum for the range
-
inline void shrinkMax(const Type &v)
Shrink a range by decreasing the maximum value.
Shrink the range by decreasing the maximum value. If the given value is larger than the current maximum (in other words, if the proposed new range would be larger than the current range), this is a no-op.
- Parameters
v – The proposed new maximum for the range
-
inline void shrinkMin(const Type &v)
Shrink a range by increasing the minimum value.
Shrink the range by increasing the minimum value. If the given value is smaller than the current minimum (in other words, if the proposed new range would be larger than the current range), this is a no-op.
- Parameters
v – The proposed new minimum for the range
-
inline Type size(void) const
Compute the size of the range.
The size of a range is defined as the difference between the minimum and the maximum. For degenerate ranges, this is zero.
Warning
Due to the nature of numbers, the result of this function can be somewhat ambiguous. For natural numbers, you could argue that the range [n, n] has size 0 or size 1. In this case we say it has size 0. The uncountable nature of the reals means this doesn’t matter for them, but this can be awkward when working with integers.
- Returns
The size of the range
-
template<std::size_t Dims, typename Type, template<typename, std::size_t> typename Vector = std::array>
class RangeXD - #include <Acts/Utilities/RangeXD.hpp>
An orthogonal range in an arbitrary number of dimensions.
By combining a number one-dimensional ranges we can (under the assumption that our axes are orthogonal) construct an orthogonal range of values. In other words, a hyperrectangular volume in space.
- Template Parameters
Dims – The number of dimensions in our range
Type – The scalar type of our ranges
Vector – The vector type used to define coordinates
Public Types
Public Functions
-
inline bool contains(const coordinate_t &v) const
Determine whether the range contains a certain point.
This is true if and only if the range contains the point in all of its dimensions.
- Parameters
v – The coordinate to check for membership in the range
- Returns
true The coordinate is inside the range
- Returns
false The coordinate is outside the range
-
inline bool degenerate(void) const
Determine whether this range is degenerate.
A degenerate multi-dimensional range has no volume and cannot contain any values. This is the case if any of its dimensions are degenerate.
- Returns
true The range is degenerate
- Returns
false The range is not degenerate
-
inline RangeXD<Dims, Type, Vector> operator&(const RangeXD<Dims, Type, Vector> &o) const
Compute the intersection of this range with another range.
The intersection of one orthogonal range with another orthogonal range is in itself an orthogonal range. This operation is commutative. This intersection between two n-dimensional ranges is defined simply as the intersection in each dimension of the two ranges.
- Parameters
o – The orthogonal range to compute the intersection with
- Returns
The intersection between the ranges
-
inline bool operator&&(const RangeXD<Dims, Type, Vector> &r) const
Determine whether this range intersects another.
Two n-dimensional ranges intersect if and only if they intersect in every one of their n dimensions. Otherwise, they are disjoint.
- Parameters
r – The other range to check
- Returns
true The ranges intersect
- Returns
false The ranges do not intersect
-
inline RangeXD<Dims, Type, Vector> &operator&=(const RangeXD<Dims, Type, Vector> &o)
Update the range to the intersection with another range.
This is the assignment version of the operator& method, meaning that it updates the object on which it is called rather than producing a new range.
- Parameters
o – The range to compute the intersection with
- Returns
This object
-
inline bool operator<=(const RangeXD<Dims, Type, Vector> &o) const
Determine whether one range is a subset of another range.
One range is a subset of another range if and only if all points contained within the first set are also contained within the second set. Alternatively, this is equivalent to each of the first range’s one-dimensional ranges being a subset of the second range’s equivalent one-dimensional range.
- Parameters
o – The other range to compare to
- Returns
true The first range is a subset of the second range
- Returns
false The first range is not a subset of the second range
-
inline bool operator==(const RangeXD<Dims, Type, Vector> &o) const
Determine whether two ranges are equal.
Two n-dimensional ranges are equal if and only if they are equal in each of their n dimensions.
- Parameters
o – The other range to check for equality
- Returns
true The ranges are equal
- Returns
false The ranges are not equal
-
inline bool operator>=(const RangeXD<Dims, Type, Vector> &o) const
Determine whether one range is a superset of another range.
One range is a superset of another range if and only if all points contained within the second range are also contained within the first range. Alternatively, this is equivalent to each of the one-dimensional ranges in the first range being a superset of the corresponding one-dimensional range in the second range.
- Parameters
o – The other range to compare to
- Returns
true The left-hand range is a superset of the right-hand range
- Returns
false The left-hand range is not a superset of the right-hand range
-
inline Range1D<Type> &operator[](const std::size_t &i)
Access one of the dimensional ranges of the volume.
- Parameters
i – The index of the dimension to access
- Returns
A reference to the dimension contained in this range
-
inline const Range1D<Type> &operator[](const std::size_t &i) const
Access one of the dimensional ranges of the volume.
- Parameters
i – The index of the dimension to access
- Returns
A reference to the dimension contained in this range
-
inline std::string toString(void) const
Represent the range as a string.
This method produces a helpful string that can be used to debug the range if needed. Not really designed to be used in production code.
- Returns
A string representing the range
-
template<typename value_t, size_t DIM>
class Ray - #include <Acts/Utilities/Ray.hpp>
Class which models a ray.
It is defined by a starting point and a direction.
- Template Parameters
value_t – The floating point type to use
DIM – The number of dimensions in which this ray is defined (2 or 3)
Public Types
-
using value_type = value_t
Re expose the value type.
Public Functions
-
Ray(const VertexType &origin, const VertexType &dir)
Constructor from an origin point and a direction.
- Parameters
origin – The origin of the ray
dir – The direction of the ray
-
inline const VertexType &dir() const
Getter for the direction.
- Returns
The direction
-
template<size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
void draw(IVisualization3D &helper, value_type far_distance = 10) const Helper to draw this ray using a given visualization helper.
- Parameters
helper – The visualization helper
far_distance – The “length” of the drawn line representing the ray
-
inline const vertex_array_type &idir() const
Getter for the element wise inverse of the direction.
- Returns
The element wise inverse.
-
inline const VertexType &origin() const
Getter for the origin.
- Returns
The origin
-
std::ostream &toStream(std::ostream &os) const
Write information on this instance to an outstream.
- Parameters
os – The out stream
- Returns
The out stream given as an argument
-
Ray<value_t, DIM> transformed(const transform_type &trf) const
Transforms this ray using a given transform and returns a new instance.
- Parameters
trf – The transform to apply
- Returns
Copy of this ray with the transform applied
-
struct RecordedMaterial
- #include <Acts/Material/MaterialInteraction.hpp>
Simple result struct to be returned It mainly acts as an internal state which is created for every propagation/extrapolation step.
Public Members
-
double materialInL0 = 0.
The accumulated materialInL0.
-
std::vector<MaterialInteraction> materialInteractions
This one is only filled when recordInteractions is switched on.
-
double materialInX0 = 0.
-
double materialInL0 = 0.
-
class RectangleBounds : public Acts::PlanarBounds
- #include <Acts/Surfaces/RectangleBounds.hpp>
Bounds for a rectangular, planar surface - it can be used to for rectangles that are symetrically centered around (0.
/0.) and for generic shifted rectangles
Public Types
-
enum BoundValues
Values:
-
enumerator eMinX
-
enumerator eMinY
-
enumerator eMaxX
-
enumerator eMaxY
-
enumerator eSize
-
enumerator eMinX
Public Functions
-
RectangleBounds() = delete
-
inline RectangleBounds(double halfX, double halfY) noexcept(false)
Constructor with halflength in x and y - symmetric.
- Parameters
halfX – halflength in X
halfY – halflength in Y
-
inline RectangleBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from fixed size array - generic.
- Parameters
values – The parameter values
-
inline RectangleBounds(const Vector2 &min, const Vector2 &max) noexcept(false)
Constructor - from min/max - generic.
- Parameters
min – The left bottom corner
max – The right top corning
-
~RectangleBounds() override = default
-
virtual const RectangleBounds &boundingBox() const final
Bounding box parameters.
- Returns
rectangle bounds for a bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
inline double halfLengthX() const
Access to the half length in X.
-
inline double halfLengthY() const
Access to the half length in Y.
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
inline const Vector2 &max() const
Get the max vertex defining the bounds.
- Returns
The max vertex
-
inline const Vector2 &min() const
Get the min vertex defining the bounds.
- Returns
The min vertex
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostream for the dump
-
inline virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.
- Returns
of the stored values for this SurfaceBounds object
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const final
Return the vertices.
Note
the number of segements is ignored in this representation
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
enum BoundValues
-
template<typename T, typename E = std::error_code>
class Result - #include <Acts/Utilities/Result.hpp>
Class which encapsulates either a valid result, or an error.
- Template Parameters
T – The valid result value
E – The error, defaults to
std::error_code
Public Functions
-
Result() = delete
Default construction is disallowed.
-
template<typename T2, typename _E = E, typename _T = T, typename = std::enable_if_t<(!std::is_same_v<_T, _E> && !std::is_constructible_v<_T, _E> && !std::is_convertible_v<_T, _E> && !std::is_constructible_v<_E, _T> && !std::is_convertible_v<_E, _T> && !(std::is_convertible_v<T2, _T> && std::is_convertible_v<T2, _E>))>>
inline Result(T2 value) noexcept Constructor from arbitrary value This constructor allows construction from any value.
This constructor is only enabled if T and E are unambiguous, meaning the cannot be implicitly converted and there is T cannot be constructed from E and vice-versa. This means that when this is invoked, the value can be propagated to the underlying variant, and the assignment will be correct, and error will be an error, and a value will be a value.
Note
If T and E are ambigious, use the
success
andfailure
static factory methods.- Template Parameters
T2 – Type of the potential assignment
- Parameters
value – The potential value, could be an actual valid value or an error.
-
inline E &error() & noexcept
Returns a reference to the error stored in the result.
Note
If
res.ok()
this method will abort (noexcept)- Returns
Reference to the error
-
inline E error() && noexcept
Returns the error by-value.
Note
If
res.ok()
this method will abort (noexcept)- Returns
The error
-
inline bool ok() const noexcept
Checks whether this result contains a valid value, and no error.
- Returns
bool Whether result contains an error or not.
-
inline T &operator*() noexcept
Returns a reference into the variant to the valid value.
Note
If
!res.ok()
, this method will abort (noexcept)- Returns
Reference to value stored in the variant.
-
inline T *operator->() noexcept
Allows to access members of the stored object with
res->foo
similar tostd::optional
.Note
If
!res.ok()
, this method will abort (noexcept)- Returns
Pointer to value stored in the variant.
-
inline Result<T, E> &operator=(Result<T, E> &&other)
Move assignment is allowed.
- Parameters
other – The other result instance, rvalue reference
- Returns
The assigned instance
-
template<typename T2, typename _E = E, typename _T = T, typename = std::enable_if_t<(!std::is_same_v<_T, _E> && !std::is_constructible_v<_T, _E> && !std::is_convertible_v<_T, _E> && !std::is_constructible_v<_E, _T> && !std::is_convertible_v<_E, _T> && !(std::is_convertible_v<T2, _T> && std::is_convertible_v<T2, _E>))>>
inline Result<T, E> &operator=(T2 value) noexcept Assignment operator from arbitrary value This operator allows construction from any value.
The same rules as for the
Result(T2 value)
constructor apply.- Template Parameters
T2 – Type of the potential assignment
- Parameters
value – The potential value, could be an actual valid value or an error.
- Returns
The assigned instance
-
inline T &value() &
Retrieves the valid value from the result object.
Note
This is the lvalue version, returns a reference to the value
- Returns
The valid value as a reference
-
inline T value() &&
Retrieves the valid value from the result object.
Note
This is the rvalue version, returns the value by-value and moves out of the variant.
- Returns
The valid value by value, moved out of the variant.
-
template<typename E>
class Result<void, E> - #include <Acts/Utilities/Result.hpp>
Template specialization for the void case.
This specialization handles the case where there is no actual return value, but an error might be returned. Returning the error directly would make handling different from other functions using the
Result<T, E>
mechanism.Result<void, E>
does not have the dereference operator, and value methods. The staticsuccess
factory does not accept a value.Note
To ease usage, this
Result<void, E>
is default constructible in the ok state, whereasResult<T, E>
is not.- Template Parameters
E – The type of the error
Public Functions
-
Result() = default
Default constructor which initializes the result in the ok state.
-
inline Result(Result<void, E> &&other)
Move constructor.
- Parameters
other – The other result object, rvalue ref
-
template<typename E2>
inline Result(E2 error) noexcept Constructor from error.
This implicitly requires E2 to be convertible to E.
- Template Parameters
E2 – The type of the actual error
- Parameters
error – The instance of the actual error
-
inline E &error() & noexcept
Returns a reference to the error stored in the result.
Note
If
res.ok()
this method will abort (noexcept)- Returns
Reference to the error
-
inline E error() && noexcept
Returns the error by-value.
Note
If
res.ok()
this method will abort (noexcept)- Returns
Reference to the error
-
inline bool ok() const noexcept
Checks whether this result is in the ok state, and no error.
- Returns
bool Whether result contains an error or not.
-
Result<void, E> &operator=(const Result<void, E> &other) = default
The (self) assignment operator is deleted.
-
template<typename propagator_t>
class RiddersPropagator - #include <Acts/Propagator/RiddersPropagator.hpp>
This class performs the Ridders algorithm to estimate the propagation of the covariance to a certain point in space.
The algorithm is based on the small deviations of the start parameters based on their uncertainty at the beginning of the propgation. This deviation is represented here by a vector of relative deviations of these parameters and fix for all parameters. So, a common choice has to be found that is able to actually fit into the order of magnitude of the uncertainty of each parameter. Using these deviations, the propagation is repeated multiple times and the final covariance matrix at a given target surface is afterwards evaluated by first order derivatives of the final state parameters wrt. the inital parameters. Therefore this evaluation represents a first order approximation of the transport jacobian. Since performing multiple propagations and a numerical evaluation of the covariance requires more time than a single propagation towards a target + a common propagation of the covariance, this class just serves to verify the results of the latter classes.
Public Functions
-
inline RiddersPropagator(propagator_t &propagator)
Constructor using a propagator.
- Parameters
propagator – [in] Underlying propagator that will be used
Constructor building a propagator.
- Template Parameters
stepper_t – Type of the stepper
navigator_t – Type of the navigator
- Parameters
stepper – [in] Stepper that will be used
navigator – [in] Navigator that will be used
-
template<typename parameters_t, typename propagator_options_t>
Result<action_list_t_result_t<CurvilinearTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const propagator_options_t &options) const Propagation method targeting curvilinear parameters.
- Template Parameters
parameters_t – Type of the start parameters
propagator_options_t – Type of the propagator options
- Parameters
start – [in] Start parameters
options – [in] Options of the propagations
- Returns
Result of the propagation
-
template<typename parameters_t, typename propagator_options_t>
Result<action_list_t_result_t<BoundTrackParameters, typename propagator_options_t::action_list_type>> propagate(const parameters_t &start, const Surface &target, const propagator_options_t &options) const Propagation method targeting bound parameters.
Note
If the target surface is a disc, the resulting covariance may be inconsistent. In this case a zero matrix is returned.
- Template Parameters
parameters_t – Type of the start parameters
propagator_options_t – Type of the propagator options
- Parameters
start – [in] Start parameters
target – [in] The target surface
options – [in] Options of the propagations
- Returns
Result of the propagation
-
inline RiddersPropagator(propagator_t &propagator)
-
struct SameSurfaceIntersection
- #include <Acts/Utilities/Intersection.hpp>
Public Functions
-
template<typename intersection_t>
inline bool operator()(const intersection_t &i1, const intersection_t &i2) const comparison operator
This is a struct to pick out intersection with identical surfaces
- Template Parameters
intersection_t – Type of the intersection object
- Parameters
i1 – First intersection to test
i2 – Second intersection to test
-
template<typename intersection_t>
-
template<typename SpacePoint>
class Seed - #include <Acts/Seeding/Seed.hpp>
Public Functions
-
Seed(const SpacePoint &b, const SpacePoint &m, const SpacePoint &u, float vertex, float seedQuality = -std::numeric_limits<float>::infinity())
-
Seed(const Seed&) = default
-
inline float seedQuality() const
-
inline const auto &sp() const
-
inline double z() const
-
Seed(const SpacePoint &b, const SpacePoint &m, const SpacePoint &u, float vertex, float seedQuality = -std::numeric_limits<float>::infinity())
-
struct SeedConfirmationRangeConfig
- #include <Acts/Seeding/SeedConfirmationRangeConfig.hpp>
contains parameters for seed confirmation
Public Members
-
size_t nTopForLargeR = 0
-
size_t nTopForSmallR = 0
-
float rMaxSeedConf = std::numeric_limits<float>::max()
-
float zMaxSeedConf = std::numeric_limits<float>::max()
-
float zMinSeedConf = std::numeric_limits<float>::min()
-
size_t nTopForLargeR = 0
-
template<typename external_spacepoint_t>
class SeedFilter - #include <Acts/Seeding/SeedFilter.hpp>
Filter seeds at various stages with the currently available information.
Public Functions
-
SeedFilter(SeedFilterConfig config, IExperimentCuts<external_spacepoint_t> *expCuts = 0)
-
SeedFilter() = delete
-
virtual ~SeedFilter() = default
-
virtual void checkReplaceSeeds(InternalSpacePoint<external_spacepoint_t> &bottomSP, InternalSpacePoint<external_spacepoint_t> &middleSP, InternalSpacePoint<external_spacepoint_t> &topSp, float zOrigin, bool isQualitySeed, float weight, std::vector<std::pair<float, std::unique_ptr<const InternalSeed<external_spacepoint_t>>>> &outCont) const
Check if there is a lower quality seed that can be replaced.
- Parameters
bottomSP – fixed bottom space point
middleSP – fixed middle space point
topSp – fixed top space point
zOrigin – on the z axis as defined by bottom and middle space point
isQualitySeed – information whether the seed is quality confirmed or not
weight – weight of the seed
outCont – container for the seeds
-
virtual void filterSeeds_1SpFixed(std::vector<std::pair<float, std::unique_ptr<const InternalSeed<external_spacepoint_t>>>> &seedsPerSpM, int &numQualitySeeds, std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt) const
Filter seeds once all seeds for one middle space point have been created.
- Parameters
seedsPerSpM – vector of pairs containing weight and seed for all
numQualitySeeds – number of high quality seeds in seed confirmation
outIt – Output iterator for the seeds for all seeds with the same middle space point
-
virtual void filterSeeds_2SpFixed(InternalSpacePoint<external_spacepoint_t> &bottomSP, InternalSpacePoint<external_spacepoint_t> &middleSP, std::vector<InternalSpacePoint<external_spacepoint_t>*> &topSpVec, std::vector<float> &invHelixDiameterVec, std::vector<float> &impactParametersVec, float zOrigin, int &numQualitySeeds, int &numSeeds, std::vector<std::pair<float, std::unique_ptr<const InternalSeed<external_spacepoint_t>>>> &outCont) const
Create InternalSeeds for the all seeds with the same bottom and middle space point and discard all others.
- Parameters
bottomSP – fixed bottom space point
middleSP – fixed middle space point
topSpVec – vector containing all space points that may be compatible with both bottom and middle space point
invHelixDiameterVec – vector containing 1/(2*r) values where r is the helix radius
impactParametersVec – vector containing the impact parameters
zOrigin – on the z axis as defined by bottom and middle space point
numQualitySeeds – number of high quality seeds in seed confirmation
numSeeds – number of seeds that did not pass the quality confirmation but were still accepted, if quality confirmation is not used this is the total number of seeds
outCont – Output container for the seeds
-
inline const IExperimentCuts<external_spacepoint_t> *getExperimentCuts() const
-
inline const SeedFilterConfig getSeedFilterConfig() const
-
SeedFilter(SeedFilterConfig config, IExperimentCuts<external_spacepoint_t> *expCuts = 0)
-
struct SeedFilterConfig
- #include <Acts/Seeding/SeedFilterConfig.hpp>
Public Functions
-
inline SeedFilterConfig toInternalUnits() const
Public Members
-
SeedConfirmationRangeConfig centralSeedConfirmationRange
-
size_t compatSeedLimit = 2
-
float compatSeedWeight = 200.
-
bool curvatureSortingInFilter = false
-
float deltaInvHelixDiameter = 0.00003 * 1. / Acts::UnitConstants::mm
-
float deltaRMin = 5. * Acts::UnitConstants::mm
-
SeedConfirmationRangeConfig forwardSeedConfirmationRange
-
float impactWeightFactor = 1.
-
int maxQualitySeedsPerSpMConf = std::numeric_limits<int>::max()
-
unsigned int maxSeedsPerSpM = 10
-
int maxSeedsPerSpMConf = std::numeric_limits<int>::max()
-
float minImpactSeedConf = 1. * Acts::UnitConstants::mm
-
float numSeedIncrement = std::numeric_limits<float>::infinity()
-
bool seedConfirmation = false
-
float seedConfMaxZOrigin = 150. * Acts::UnitConstants::mm
-
float seedConfMinBottomRadius = 60. * Acts::UnitConstants::mm
-
float seedWeightIncrement = 0
-
bool useDeltaRorTopRadius = false
-
inline SeedFilterConfig toInternalUnits() const
-
template<typename external_spacepoint_t, typename platform_t = void*>
class Seedfinder - #include <Acts/Seeding/Seedfinder.hpp>
Disallow default instantiation, copy, assignment
-
Seedfinder() = delete
-
Seedfinder(const Seedfinder<external_spacepoint_t, platform_t>&) = delete
-
Seedfinder<external_spacepoint_t, platform_t> &operator=(const Seedfinder<external_spacepoint_t, platform_t>&) = delete
Public Functions
-
Seedfinder(Acts::SeedfinderConfig<external_spacepoint_t> config)
The only constructor.
Requires a config object.
- Parameters
config – the configuration for the Seedfinder
-
~Seedfinder() = default
-
template<template<typename...> typename container_t, typename sp_range_t>
void createSeedsForGroup(State &state, std::back_insert_iterator<container_t<Seed<external_spacepoint_t>>> outIt, sp_range_t bottomSPs, sp_range_t middleSPs, sp_range_t topSPs, Extent rRangeSPExtent) const Create all seeds from the space points in the three iterators.
Can be used to parallelize the seed creation
Note
Ranges must return pointers.
Note
Ranges must be separate objects for each parallel call.
- Parameters
state – State object that holds memory used
outIt – Output iterator for the seeds in the group
bottomSPs – group of space points to be used as innermost SP in a seed.
middleSPs – group of space points to be used as middle SP in a seed.
topSPs – group of space points to be used as outermost SP in a seed.
rRangeSPExtent – extent containing r values of all SP.
-
template<typename sp_range_t>
std::vector<Seed<external_spacepoint_t>> createSeedsForGroup(sp_range_t bottomSPs, sp_range_t middleSPs, sp_range_t topSPs) const Compatibility method for the new-style seed finding API.
This method models the old-style seeding API where we only need a container for the bottom, middle, and top space points. Also, the results are returned by value instead of inserted into an inserter.
Note
This method is a very simply wrapper around the more modern API.
Warning
The performance of the seeding code is far greater if the new API is used, and this is recommended for all new uses which do not require backwards-compatibility.
- Template Parameters
sp_range_t – container type for the seed point collections.
- Parameters
bottomSPs – group of space points to be used as innermost SP in a seed.
middleSPs – group of space points to be used as middle SP in a seed.
topSPs – group of space points to be used as outermost SP in a seed.
- Returns
a vector of seeds.
-
struct State
- #include <Acts/Seeding/Seedfinder.hpp>
Public Members
-
std::vector<InternalSpacePoint<external_spacepoint_t>*> compatBottomSP
-
std::vector<InternalSpacePoint<external_spacepoint_t>*> compatTopSP
-
std::vector<float> curvatures
-
std::vector<float> etaVec
-
std::vector<float> impactParameters
-
std::vector<LinCircle> linCircleBottom
-
std::vector<LinCircle> linCircleTop
-
std::vector<float> ptVec
-
std::vector<std::pair<float, std::unique_ptr<const InternalSeed<external_spacepoint_t>>>> seedsPerSpM
-
std::vector<InternalSpacePoint<external_spacepoint_t>*> topSpVec
-
std::vector<InternalSpacePoint<external_spacepoint_t>*> compatBottomSP
-
Seedfinder() = delete
-
template<typename SpacePoint>
struct SeedfinderConfig - #include <Acts/Seeding/SeedfinderConfig.hpp>
Public Functions
-
inline SeedfinderConfig toInternalUnits() const
Public Members
-
bool arithmeticAverageCotTheta = false
-
Acts::Vector2 beamPos = {0 * Acts::UnitConstants::mm, 0 * Acts::UnitConstants::mm}
-
float bFieldInZ = 2.08 * Acts::UnitConstants::T
-
float binSizeR = 1. * Acts::UnitConstants::mm
-
SeedConfirmationRangeConfig centralSeedConfirmationRange
-
float collisionRegionMax = +150 * Acts::UnitConstants::mm
-
float collisionRegionMin = -150 * Acts::UnitConstants::mm
-
float cotThetaMax = 7.40627
-
float deltaRMax = 270 * Acts::UnitConstants::mm
-
float deltaRMaxBottomSP = std::numeric_limits<float>::quiet_NaN()
-
float deltaRMaxTopSP = std::numeric_limits<float>::quiet_NaN()
-
float deltaRMiddleMaxSPRange = 10. * Acts::UnitConstants::mm
-
float deltaRMiddleMinSPRange = 10. * Acts::UnitConstants::mm
-
float deltaRMin = 5 * Acts::UnitConstants::mm
-
float deltaRMinBottomSP = std::numeric_limits<float>::quiet_NaN()
-
float deltaRMinTopSP = std::numeric_limits<float>::quiet_NaN()
-
float deltaZMax = std::numeric_limits<float>::infinity() * Acts::UnitConstants::mm
-
bool forceRadialSorting = false
-
SeedConfirmationRangeConfig forwardSeedConfirmationRange
-
Delegate<float(const SpacePoint&)> getBottomHalfStripLength
-
Delegate<Acts::Vector3(const SpacePoint&)> getBottomStripDirection
-
Delegate<Acts::Vector3(const SpacePoint&)> getStripCenterDistance
-
Delegate<float(const SpacePoint&)> getTopHalfStripLength
-
Delegate<Acts::Vector3(const SpacePoint&)> getTopStripCenterPosition
-
Delegate<Acts::Vector3(const SpacePoint&)> getTopStripDirection
-
float highland = 0
-
float impactMax = 20. * Acts::UnitConstants::mm
-
bool interactionPointCut = false
-
int maxBlockSize = 1024
-
float maxPtScattering = 10 * Acts::UnitConstants::GeV
-
float maxScatteringAngle2 = 0
-
unsigned int maxSeedsPerSpM = 5
-
float minHelixDiameter2 = 0
-
float minPt = 400. * Acts::UnitConstants::MeV
-
int nAvgTrplPerSpBLimit = 2
-
int nTrplPerSpBLimit = 100
-
float phiMax = M_PI
-
float phiMin = -M_PI
-
float pT2perRadius = 0
-
float pTPerHelixRadius = 0
-
float radLengthPerSeed = 0.05
-
float rAlign = 0 * Acts::UnitConstants::mm
-
float rMax = 600 * Acts::UnitConstants::mm
-
float rMin = 33 * Acts::UnitConstants::mm
-
std::vector<std::vector<float>> rRangeMiddleSP
-
bool seedConfirmation = false
-
std::shared_ptr<Acts::SeedFilter<SpacePoint>> seedFilter
-
float sigmaError = 5
-
float sigmapT2perRadius = 0
-
float sigmaScattering = 5
-
bool skipPreviousTopSP = false
-
float toleranceParam = 1.1 * Acts::UnitConstants::mm
-
bool useDetailedDoubleMeasurementInfo = false
-
bool useVariableMiddleSPRange = false
-
float zAlign = 0 * Acts::UnitConstants::mm
-
std::vector<float> zBinEdges
-
std::vector<size_t> zBinsCustomLooping = {}
-
float zMax = 2800 * Acts::UnitConstants::mm
-
float zMin = -2800 * Acts::UnitConstants::mm
-
inline SeedfinderConfig toInternalUnits() const
-
template<typename external_spacepoint_t>
class SeedFinderOrthogonal - #include <Acts/Seeding/SeedFinderOrthogonal.hpp>
Public Types
-
using internal_sp_t = InternalSpacePoint<external_spacepoint_t>
The spacepoint type used by this seeder internally.
-
using seed_t = Seed<external_spacepoint_t>
The seed type used by this seeder internally.
-
using tree_t = KDTree<NDims, internal_sp_t*, ActsScalar, std::array, 4>
The k-d tree type used by this seeder internally, which is three-dimensional, contains internal spacepoint pointers, uses the Acts scalar type for coordinates, stores its coordinates in std::arrays, and has leaf size 4.
Public Functions
-
SeedFinderOrthogonal(Acts::SeedFinderOrthogonalConfig<external_spacepoint_t> config)
Construct a new orthogonal seed finder.
- Parameters
config – The configuration parameters for this seed finder.
-
SeedFinderOrthogonal() = delete
-
SeedFinderOrthogonal(const SeedFinderOrthogonal<external_spacepoint_t>&) = delete
-
~SeedFinderOrthogonal() = default
Destroy the orthogonal seed finder object.
-
template<typename input_container_t, typename output_container_t>
void createSeeds(const input_container_t &spacePoints, output_container_t &out_cont) const Perform seed finding, appending seeds to a container.
This method performs seed finding through an orthogonal range search strategy. This strategy differs from binning approaches because it selects seeds constructively rather than destructively; instead of trying a large number of possible space point combinations and then rejecting many of them, this algorithm tries to only consider valid seed candidates to reduce combinatorics.
In addition, this algorithm replaces the binning step used in other seed finding algorithms with the construction of a k-d tree, which allows us to efficiently search for space points within a given range.
The core idea behind this algorithm is to create axis-aligned bounding boxes around the region of validity for a seed candidate (be it a bottom spacepoint for a given middle, a top for a given middle, a middle for a given bottom, or any other combination), and then searching the detector volume for points that lie inside that AABB.
- Template Parameters
input_container_t – The type of the input spacepoint container.
output_container_t – The type of the output seed container.
- Parameters
spacePoints – The input spacepoints from which to create seeds.
out_cont – The output container to write seeds to.
-
template<typename input_container_t>
std::vector<seed_t> createSeeds(const input_container_t &spacePoints) const Perform seed finding, returning a new container of seeds.
This is a filterCandidates method for scenarios where a non-inserter API is more ergonomic. In general, the inserter-based method should be preferred as it is more flexible and usually more performant. For more information about the seeding algorithm, please see that function.
- Template Parameters
input_container_t – The type of the input spacepoint container.
- Parameters
spacePoints – The input spacepoints from which to create seeds.
- Returns
A vector of seeds.
-
SeedFinderOrthogonal<external_spacepoint_t> &operator=(const SeedFinderOrthogonal<external_spacepoint_t>&) = delete
Public Static Attributes
-
static constexpr std::size_t NDims = 3
Set the number of dimensions in which to embed points.
This is just 3 for now (phi, r, and z), but we might want to increase or decrease this number in the future.
-
using internal_sp_t = InternalSpacePoint<external_spacepoint_t>
-
template<typename SpacePoint>
struct SeedFinderOrthogonalConfig - #include <Acts/Seeding/SeedFinderOrthogonalConfig.hpp>
Public Functions
-
inline SeedFinderOrthogonalConfig toInternalUnits() const
Public Members
-
Acts::Vector2 beamPos = {0 * Acts::UnitConstants::mm, 0 * Acts::UnitConstants::mm}
-
float bFieldInZ = 2.08 * Acts::UnitConstants::T
-
float collisionRegionMax = +150 * Acts::UnitConstants::mm
-
float collisionRegionMin = -150 * Acts::UnitConstants::mm
-
float cotThetaMax = 7.40627
-
float deltaPhiMax = 0.085
-
float deltaRMaxBottomSP = 270 * Acts::UnitConstants::mm
-
float deltaRMaxTopSP = 270 * Acts::UnitConstants::mm
-
float deltaRMinBottomSP = 5 * Acts::UnitConstants::mm
-
float deltaRMinTopSP = 5 * Acts::UnitConstants::mm
-
float highland = 0
-
float impactMax = 20. * Acts::UnitConstants::mm
-
float maxPtScattering = 10 * Acts::UnitConstants::GeV
-
float maxScatteringAngle2 = 0
-
unsigned int maxSeedsPerSpM = 5
-
float minHelixDiameter2 = 0
-
float minPt = 400. * Acts::UnitConstants::MeV
-
float phiMax = M_PI
-
float phiMin = -M_PI
-
float pT2perRadius = 0
-
float pTPerHelixRadius = 0
-
float radLengthPerSeed = 0.05
-
float rMax = 600 * Acts::UnitConstants::mm
-
float rMaxMiddle = 120.f * Acts::UnitConstants::mm
-
float rMin = 33 * Acts::UnitConstants::mm
-
float rMinMiddle = 60.f * Acts::UnitConstants::mm
-
std::shared_ptr<Acts::SeedFilter<SpacePoint>> seedFilter
-
float sigmapT2perRadius = 0
-
float sigmaScattering = 5
-
float zMax = 2800 * Acts::UnitConstants::mm
-
float zMin = -2800 * Acts::UnitConstants::mm
-
inline SeedFinderOrthogonalConfig toInternalUnits() const
-
class Segmentation
- #include <Acts/Digitization/Segmentation.hpp>
Segmentation Base class.
This helper class allows to define an arbitrary readout segmentation for the geoemtric digitization, provided a shape of the module, it creates the segmentation surfaces and hands them to the digitization module
Since the segmentation description might be identical for many elements while the lorentz angle may change, lorentzAngle and readoutDirection are provided and th the segmenation class only creates the surfaces for the module, but hosts the binning information.
Subclassed by Acts::CartesianSegmentation
Public Functions
-
virtual ~Segmentation() = default
Virtual Destructor.
-
virtual const BinUtility &binUtility() const = 0
return the bin utility that defines the readout
-
virtual DigitizationCell cell(const Vector3 &position) const = 0
Get the digitization cell fropm a 3D position.
ignores the shift, i.e. assumenes in to be in cell frame
- Parameters
position – is the position for which the cell is requested
- Returns
is a cell with cell ids
-
virtual DigitizationCell cell(const Vector2 &position) const = 0
Get the digitization cell fropm a 2D position.
ignores the shift, i.e. assumenes in to be in cell frame
- Parameters
position – is the position for which the cell is requested
- Returns
is a cell with cell ids
-
virtual Vector2 cellPosition(const DigitizationCell &dCell) const = 0
Calculate the cell Position from the Id.
- Parameters
dCell – the digitization cell
- Returns
the center position of the associated cell
-
virtual void createSegmentationSurfaces(SurfacePtrVector &boundarySurfaces, SurfacePtrVector &segmentationSurfacesX, SurfacePtrVector &segmentationSurfacesY, double halfThickness, int readoutDirection, double lorentzAngle) const = 0
Create the segmentation surfaces in X.
This method is only used if the full 3D digitization is done
- Parameters
boundarySurfaces – vector to be filled
segmentationSurfacesX – are the segmetation boundaries in X
segmentationSurfacesY – are the segmetation boundaries in Y
halfThickness – is the half thickness in z of the module
readoutDirection – is the direction w.r.t normal vector where the readout is given : -1, 0, 1 possible
lorentzAngle – is the lorentz angle measured from the local z towards x axis
-
virtual DigitizationStep digitizationStep(const Vector3 &start, const Vector3 &end, double halfThickness, int readoutDirection, double lorentzAngle) const = 0
Fill the associated digitization cell from the start and end position in 3D correct for lorentz effect if needed.
- Parameters
start – is the start position of the step
end – is the end position of the step
halfThickness – is the half thickness in z
readoutDirection – is the readout direction with respect to local z
lorentzAngle – is the lorentz angle measured from local z towards x
- Returns
is a fully calculated digitzation step
-
virtual const SurfaceBounds &moduleBounds() const = 0
return the surface bounds by reference
-
virtual ~Segmentation() = default
-
template<class charge_t>
class SingleBoundTrackParameters - #include <Acts/EventData/SingleBoundTrackParameters.hpp>
Track parameters bound to a reference surface for a single track.
This is intended as a user-facing data class that adds additional accessors and charge/momentum interpretation on top of the pure parameters vector. All parameters and their corresponding covariance matrix are stored in bound parametrization. The specific definition of the local spatial parameters is defined by the associated surface.
Note
This class holds shared ownership on its reference surface.
- Template Parameters
charge_t – Helper type to interpret the particle charge/momentum
Subclassed by Acts::SingleCurvilinearTrackParameters< charge_t >
Public Types
-
using CovarianceMatrix = BoundSymMatrix
-
using ParametersVector = BoundVector
-
using Scalar = ActsScalar
Public Functions
Construct from a parameters vector on the surface and particle charge.
In principle, only the charge magnitude is needed her to allow unambigous extraction of the absolute momentum. The particle charge is required as an input here to be consistent with the other constructors below that that also take the charge as an input. The charge sign is only used in debug builds to check for consistency with the q/p parameter.
- Parameters
surface – Reference surface the parameters are defined on
params – Bound parameters vector
q – Particle charge
cov – Bound parameters covariance matrix
Construct from a parameters vector on the surface.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge type is default-constructible.
- Parameters
surface – Reference surface the parameters are defined on
params – Bound parameters vector
cov – Bound parameters covariance matrix
-
SingleBoundTrackParameters() = delete
Parameters are not default constructible due to the charge type.
-
SingleBoundTrackParameters(const SingleBoundTrackParameters&) = default
-
SingleBoundTrackParameters(SingleBoundTrackParameters&&) = default
-
~SingleBoundTrackParameters() = default
-
inline Scalar absoluteMomentum() const
Absolute momentum.
-
inline Scalar charge() const
Particle electric charge.
-
inline const std::optional<CovarianceMatrix> &covariance() const
Optional covariance matrix.
-
inline Vector4 fourPosition(const GeometryContext &geoCtx) const
Space-time position four-vector.
This uses the associated surface to transform the local position on the surface to globalcoordinates. This requires a geometry context to select the appropriate transformation and might be a computationally expensive operation.
- Parameters
geoCtx – [in] Geometry context for the local-to-global transformation
-
template<BoundIndices kIndex>
inline Scalar get() const Access a single parameter value indentified by its index.
- Template Parameters
kIndex – Track parameter index
-
inline Vector3 momentum() const
Momentum three-vector.
-
SingleBoundTrackParameters &operator=(const SingleBoundTrackParameters&) = default
-
SingleBoundTrackParameters &operator=(SingleBoundTrackParameters&&) = default
-
inline const ParametersVector ¶meters() const
Parameters vector.
-
inline Vector3 position(const GeometryContext &geoCtx) const
Spatial position three-vector.
This uses the associated surface to transform the local position on the surface to globalcoordinates. This requires a geometry context to select the appropriate transformation and might be a computationally expensive operation.
- Parameters
geoCtx – [in] Geometry context for the local-to-global transformation
-
inline RotationMatrix3 referenceFrame(const GeometryContext &geoCtx) const
Reference frame in which the local error is defined.
For planar surfaces, this is the transformation local-to-global rotation matrix. For non-planar surfaces, it is the local-to-global rotation matrix of the tangential plane at the track position.
- Parameters
geoCtx – [in] Geometry context for the local-to-global transformation
-
inline const Surface &referenceSurface() const
Reference surface onto which the parameters are bound.
-
inline Scalar time() const
Time coordinate.
-
inline Scalar transverseMomentum() const
Transverse momentum.
-
inline Vector3 unitDirection() const
Unit direction three-vector, i.e.
the normalized momentum three-vector.
Public Static Functions
Factory to construct from four-position, direction, absolute momentum, and charge.
Note
The returned result indicates whether the free parameters could successfully be converted to on-surface parameters.
- Parameters
surface – Reference surface the parameters are defined on
geoCtx – Geometry context for the local-to-global transformation
pos4 – Track position/time four-vector
dir – Track direction three-vector; normalization is ignored.
p – Absolute momentum
q – Particle charge
cov – Bound parameters covariance matrix
Factory to construct from four-position, direction, and charge-over-momentum.
Note
This factory is only available if there are no potential charge ambiguities, i.e. the charge type is default-constructible. The position must be located on the surface.
Note
The returned result indicates whether the free parameters could successfully be converted to on-surface parameters.
- Parameters
surface – Reference surface the parameters are defined on
geoCtx – Geometry context for the local-to-global transformation
pos4 – Track position/time four-vector
dir – Track direction three-vector; normalization is ignored.
qOverP – Charge-over-momentum-like parameter
cov – Bound parameters covariance matrix
-
template<typename charge_t>
class SingleCurvilinearTrackParameters : public Acts::SingleBoundTrackParameters<charge_t> - #include <Acts/EventData/SingleCurvilinearTrackParameters.hpp>
Curvilinear track parameters for a single track.
This is intended as a user-facing data class that adds additional accessors and charge/momentum interpretation on top of the pure parameters vector. All parameters and their corresponding covariance matrix are stored in curvilinear parametrization.
See also
SingleBoundTrackParameters
- Template Parameters
charge_t – Helper type to interpret the particle charge/momentum
Public Types
-
using CovarianceMatrix = BoundSymMatrix
-
using ParametersVector = BoundVector
-
using Scalar = ActsScalar
Public Functions
-
inline SingleCurvilinearTrackParameters(const Vector4 &pos4, const Vector3 &dir, Scalar p, Scalar q, std::optional<CovarianceMatrix> cov = std::nullopt)
Construct from four-position, direction, absolute momentum, and charge.
- Parameters
pos4 – Track position/time four-vector
dir – Track direction three-vector; normalization is ignored.
p – Absolute momentum
q – Particle charge
cov – Curvilinear bound parameters covariance matrix
-
template<typename T = charge_t, std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
inline SingleCurvilinearTrackParameters(const Vector4 &pos4, const Vector3 &dir, Scalar qOverP, std::optional<CovarianceMatrix> cov = std::nullopt) Construct from four-position, direction, and charge-over-momentum.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge interpretation type is default-constructible.
- Parameters
pos4 – Track position/time four-vector
dir – Track direction three-vector; normalization is ignored.
qOverP – Charge-over-momentum-like parameter
cov – Curvilinear bound parameters covariance matrix
-
inline SingleCurvilinearTrackParameters(const Vector4 &pos4, Scalar phi, Scalar theta, Scalar p, Scalar q, std::optional<CovarianceMatrix> cov = std::nullopt)
Construct from four-position, angles, absolute momentum, and charge.
- Parameters
pos4 – Track position/time four-vector
phi – Transverse track direction angle
theta – Longitudinal track direction angle
p – Absolute momentum
q – Particle charge
cov – Curvilinear bound parameters covariance matrix
-
template<typename T = charge_t, std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
inline SingleCurvilinearTrackParameters(const Vector4 &pos4, Scalar phi, Scalar theta, Scalar qOverP, std::optional<CovarianceMatrix> cov = std::nullopt) Construct from four-position, angles, and charge-over-momentum.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge interpretation type is default-constructible.
- Parameters
pos4 – Track position/time four-vector
phi – Transverse track direction angle
theta – Longitudinal track direction angle
qOverP – Charge-over-momentum-like parameter
cov – Curvilinear bound parameters covariance matrix
-
SingleCurvilinearTrackParameters() = delete
Parameters are not default constructible due to the charge type.
-
SingleCurvilinearTrackParameters(const SingleCurvilinearTrackParameters&) = default
-
SingleCurvilinearTrackParameters(SingleCurvilinearTrackParameters&&) = default
-
~SingleCurvilinearTrackParameters() = default
-
SingleCurvilinearTrackParameters &operator=(const SingleCurvilinearTrackParameters&) = default
-
SingleCurvilinearTrackParameters &operator=(SingleCurvilinearTrackParameters&&) = default
-
template<class charge_t>
class SingleFreeTrackParameters - #include <Acts/EventData/SingleFreeTrackParameters.hpp>
Track parameters not bound to a surface for a single track.
Parameters and covariance matrix are stored using the free parametrization defined in
enum FreeIndices
.- Template Parameters
charge_t – Helper type to interpret the particle charge
Public Types
-
using CovarianceMatrix = FreeSymMatrix
-
using ParametersVector = FreeVector
-
using Scalar = ActsScalar
Public Functions
-
inline SingleFreeTrackParameters(const ParametersVector ¶ms, Scalar q, std::optional<CovarianceMatrix> cov = std::nullopt)
Construct from a parameters vector and particle charge.
In principle, only the charge magnitude is needed her to allow unambigous extraction of the absolute momentum. The particle charge is required as an input here to be consistent with the other constructors below that that also take the charge as an input. The charge sign is only used in debug builds to check for consistency with the q/p parameter.
- Parameters
params – Free parameters vector
q – Particle charge
cov – Free parameters covariance matrix
-
template<typename T = charge_t, std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
inline SingleFreeTrackParameters(const ParametersVector ¶ms, std::optional<CovarianceMatrix> cov = std::nullopt) Construct from a parameters vector.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge interpretation type is default-constructible.
- Parameters
params – Free parameters vector
cov – Free parameters covariance matrix
- Template Parameters
T – Internal helper template be able to check charge type
-
inline SingleFreeTrackParameters(const Vector4 &pos4, Scalar phi, Scalar theta, Scalar p, Scalar q, std::optional<CovarianceMatrix> cov = std::nullopt)
Construct from four-position, angles, absolute momentum, and charge.
- Parameters
pos4 – Track position/time four-vector
phi – Transverse track direction angle
theta – Longitudinal track direction angle
p – Absolute momentum
q – Particle charge
cov – Free parameters covariance matrix
-
template<typename T = charge_t, std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
inline SingleFreeTrackParameters(const Vector4 &pos4, Scalar phi, Scalar theta, Scalar qOverP, std::optional<CovarianceMatrix> cov = std::nullopt) Construct from four-position, angles, and charge-over-momentum.
This constructor is only available if there are no potential charge ambiguities, i.e. the charge interpretation type is default-constructible.
- Parameters
pos4 – Track position/time four-vector
phi – Transverse track direction angle
theta – Longitudinal track direction angle
qOverP – Charge-over-momentum-like parameter
cov – Free parameters covariance matrix
-
SingleFreeTrackParameters() = delete
Parameters are not default constructible due to the charge type.
-
SingleFreeTrackParameters(const SingleFreeTrackParameters&) = default
-
SingleFreeTrackParameters(SingleFreeTrackParameters&&) = default
-
~SingleFreeTrackParameters() = default
-
inline Scalar absoluteMomentum() const
Absolute momentum.
-
inline Scalar charge() const
Particle electric charge.
-
inline const std::optional<CovarianceMatrix> &covariance() const
Optional covariance matrix.
-
inline Vector4 fourPosition() const
Space-time position four-vector.
-
template<FreeIndices kIndex>
inline Scalar get() const Access a single parameter value indentified by its index.
- Template Parameters
kIndex – Track parameter index
-
inline Vector3 momentum() const
Momentum three-vector.
-
SingleFreeTrackParameters &operator=(const SingleFreeTrackParameters&) = default
-
SingleFreeTrackParameters &operator=(SingleFreeTrackParameters&&) = default
-
inline const ParametersVector ¶meters() const
Parameters vector.
-
inline Vector3 position() const
Spatial position three-vector.
-
inline Scalar time() const
Time coordinate.
-
inline Scalar transverseMomentum() const
Transverse momentum.
-
inline Vector3 unitDirection() const
Unit direction three-vector, i.e. the normalized momentum three-vector.
-
struct SinglyCharged
- #include <Acts/EventData/Charge.hpp>
Charge and momentum interpretation for particles with +-e charge.
Public Functions
-
SinglyCharged() = default
-
template<typename T>
inline constexpr SinglyCharged(T absQ) noexcept Construct and verify the input charge magnitude (in debug builds).
This constructor is only provided to allow consistent construction.
Friends
-
inline friend constexpr bool operator==(SinglyCharged, SinglyCharged) noexcept
Compare for equality.
This is always
true
asSinglyCharged
has no internal state. Must be available to provide a consistent interface.
-
SinglyCharged() = default
-
class SolenoidBField : public Acts::MagneticFieldProvider
- #include <Acts/MagneticField/SolenoidBField.hpp>
Implements a multi-coil solenoid magnetic field.
On every call, the field is evaluated at that exact position. The field has radially symmetry, the field vectors point in +z direction. The config exposes a target field value in the center. This value is used to empirically determine a scale factor which reproduces this field value in the center.
E_1(k^2) = complete elliptic integral of the 1st kind E_2(k^2) = complete elliptic integral of the 2nd kind
E_1(k^2) and E_2(k^2) are usually indicated as K(k^2) and E(k^2) in literature, respectively _ 2 / pi / 2 2 2 - 1 / 2 E (k ) = | ( 1 - k sin {theta} ) dtheta 1 _/ 0
2 / pi / 2| / 2 2 E (k ) = | |/ 1 - k sin {theta} dtheta 2 _/ 0_ ____________________
k^2 = is a function of the point (r, z) and of the radius of the coil R
2 4Rr k = ————— 2 2 (R + r) + z Using these, you can evaluate the two components B_r and B_z of the magnetic field: _ _ mu I | / 2 \ | 0 kz | |2 - k | 2 2 | B (r, z) = –— —— | |—-—|E (k ) - E (k ) | r 4pi ___ | | 2| 2 1 | | / 3 |_ \2 - 2k / _| |/ Rr
mu I | / 2 \ | 0 k | | (R + r)k - 2r | 2 2 | B (r,z) = –— -— | | ———–— | E (k ) + E (k ) | z 4pi __ | | 2 | 2 1 | |/Rr |_ \ 2r(1 - k ) / _|_ _
Public Functions
-
SolenoidBField(Config config)
the constructur with a shared pointer
Note
since it is a shared field, we enforce it to be const
- Template Parameters
bField – is the shared BField to be stored
-
Vector2 getField(const Vector2 &position) const
Retrieve magnetic field value in local (r,z) coordinates.
- Parameters
position – [in] local 2D position
-
Vector3 getField(const Vector3 &position) const
Get the B field at a position.
- Parameters
position – The position to query at
-
virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value at a given location.
Requires a cache object created through makeCache().
- Parameters
position – [in] global 3D position for the lookup
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector at given position
-
virtual Result<Vector3> getFieldGradient(const Vector3 &position, ActsMatrix<3, 3> &derivative, MagneticFieldProvider::Cache &cache) const override
Retrieve magnetic field value its its gradient.
Requires a cache object created through makeCache().
Note
currently the derivative is not calculated
- Parameters
position – [in] global 3D position
derivative – [out] gradient of magnetic field vector as (3x3) matrix
cache – [inout] Field provider specific cache object
- Returns
magnetic field vector
-
virtual MagneticFieldProvider::Cache makeCache(const MagneticFieldContext &mctx) const override
Make an opaque cache for the magnetic field.
Instructs the specific implementation to generate a
Cache
instance for magnetic field lookup.- Parameters
mctx – The magnetic field context to generate cache for
- Returns
Cache The opaque cache object
-
struct Cache
- #include <Acts/MagneticField/SolenoidBField.hpp>
Public Functions
-
inline Cache(const MagneticFieldContext &mctx)
Constructor with magnetic field context.
- Parameters
mctx – the magnetic field context
-
inline Cache(const MagneticFieldContext &mctx)
-
struct Config
- #include <Acts/MagneticField/SolenoidBField.hpp>
Config struct for the SolenoidBfield.
Public Members
-
double bMagCenter
The target magnetic field strength at the center.
This will be used to scale coefficients
-
double length
Extent of the solenoid in z.
It goes from -length/2 to +length/2 by convention
-
size_t nCoils
The number of coils that make up the solenoid.
-
double radius
Radius at which the coils are located.
-
double bMagCenter
-
SolenoidBField(Config config)
-
class SourceLink
- #include <Acts/EventData/SourceLink.hpp>
Base class for all SourceLink objects.
Exposes a minimal nonvirtual interface
Subclassed by Acts::DigitizationSourceLink
Public Functions
-
inline virtual ~SourceLink() = 0
Virtual destructor, required for safely storing source links as their base.
-
inline constexpr GeometryIdentifier geometryId() const
Getter for the geometry identifier.
- Returns
The GeometryIdentifier
-
inline virtual ~SourceLink() = 0
-
template<typename spacepoint_t>
class SpacePointBuilder - #include <Acts/SpacePointFormation/SpacePointBuilder.hpp>
After the particle interaction with surfaces are recorded and digitized measurements on the pixel or strip detectors need further treatment.
This class takes the measurements and provides the corresponding space points.
Public Types
-
using Measurement = Acts::BoundVariantMeasurement
Public Functions
-
SpacePointBuilder(SpacePointBuilderConfig cfg, std::function<spacepoint_t(Acts::Vector3, Acts::Vector2, boost::container::static_vector<const SourceLink*, 2>)> func, std::unique_ptr<const Logger> logger = getDefaultLogger("SpamcePointBuilder", Logging::INFO))
- Parameters
cfg – The configuration for the space point builder
func – The function that provides user’s SP constructor with global pos, global cov, and sourceLinks.
logger – The logging instance
-
SpacePointBuilder() = default
-
template<template<typename...> typename container_t>
void buildSpacePoint(const GeometryContext &gctx, const std::vector<const Measurement*> &measurements, const SpacePointBuilderOptions &opt, std::back_insert_iterator<container_t<spacepoint_t>> spacePointIt) const Calculates the space points out of a given collection of measurements and stores the results.
- Parameters
gctx – The current geometry context object, e.g. alignment
measurements – vector of measurements
opt – option for the space point bulding. It contains the ends of the strips for strip SP building
spacePointIt – Output iterator for the space point
-
void makeMeasurementPairs(const GeometryContext &gctx, const std::vector<const Measurement*> &measurementsFront, const std::vector<const Measurement*> &measurementsBack, std::vector<std::pair<const Measurement*, const Measurement*>> &measurementPairs) const
Searches possible combinations of two measurements on different surfaces that may come from the same particles.
- Parameters
gctx – The current geometry context object, e.g. alignment
measurementsFront – vector of measurements on a surface
measurementsBack – vector of measurements on another surface
measurementPairs – storage of the measurement pairs
-
using Measurement = Acts::BoundVariantMeasurement
-
struct SpacePointBuilderConfig
- #include <Acts/SpacePointFormation/SpacePointBuilderConfig.hpp>
Public Functions
-
SpacePointBuilderConfig() = default
Public Members
-
double diffDist = 100. * UnitConstants::mm
Accepted distance between two clusters.
-
double diffPhi2 = 1.
Accepted squared difference in phi for two clusters.
-
double diffTheta2 = 1.
Accepted squared difference in theta for two clusters.
-
double stripLengthGapTolerance = 0.01
Allowed increase of strip length wrt gaps between strips.
-
double stripLengthTolerance = 0.01
Allowed increase of strip length.
-
std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
Tracking geometry.
-
bool usePerpProj = false
Perform the perpendicular projection for space point finding.
-
Vector3 vertex = {0., 0., 0.}
vertex position
-
SpacePointBuilderConfig() = default
-
struct SpacePointBuilderOptions
- #include <Acts/SpacePointFormation/SpacePointBuilderOptions.hpp>
-
struct SpacePointGridConfig
- #include <Acts/Seeding/SpacePointGrid.hpp>
Public Functions
-
inline SpacePointGridConfig toInternalUnits() const
Public Members
-
float bFieldInZ
-
float cotThetaMax
-
float deltaRMax
-
float impactMax
-
float minPt
-
int phiBinDeflectionCoverage = 1
-
float phiMax = M_PI
-
float phiMin = -M_PI
-
float rMax
-
std::vector<float> zBinEdges
-
float zMax
-
float zMin
-
inline SpacePointGridConfig toInternalUnits() const
-
class SpacePointGridCreator
- #include <Acts/Seeding/SpacePointGrid.hpp>
Public Static Functions
-
template<typename external_spacepoint_t>
static std::unique_ptr<SpacePointGrid<external_spacepoint_t>> createGrid(const Acts::SpacePointGridConfig &_config)
-
template<typename external_spacepoint_t>
-
struct SpacePointParameters
- #include <Acts/Utilities/SpacePointUtility.hpp>
Storage container for variables related to the calculation of space points.
Public Members
-
Vector3 firstBtmToTop
Vector pointing from bottom to top end of first SDE.
-
Vector3 firstBtmToTopXvtxToFirstMid2
Cross product between firstBtmToTop and vtxToFirstMid2.
-
double limit = 1.
Regular limit of the absolut values of SpacePointParameters::m and SpacePointParameters::n.
-
double limitExtended = 0.
Limit of SpacePointParameters::m and SpacePointParameters::n in case of variable vertex.
-
double m = 0.
Parameter that determines the hit position on the first SDE.
-
double mag_firstBtmToTop = 0.
Magnitude of SpacePointParameters::firstBtmToTop.
-
double n = 0.
Parameter that determines the hit position on the second SDE.
-
Vector3 secondBtmToTop
Vector pointing from bottom to top end of second SDE.
-
Vector3 secondBtmToTopXvtxToSecondMid2
Cross product between secondBtmToTop and vtxToSecondMid2.
-
Vector3 vtxToFirstMid2
Twice the vector pointing from vertex to to midpoint of first SDE.
-
Vector3 vtxToSecondMid2
Twice the vector pointing from vertex to to midpoint of second SDE.
-
Vector3 firstBtmToTop
-
class SpacePointUtility
- #include <Acts/Utilities/SpacePointUtility.hpp>
Public Types
-
using Measurement = Acts::BoundVariantMeasurement
Public Functions
-
inline SpacePointUtility(SpacePointBuilderConfig cfg)
Constructor.
-
Result<double> calcPerpendicularProjection(const std::pair<Vector3, Vector3> &stripEnds1, const std::pair<Vector3, Vector3> &stripEnds2, SpacePointParameters &spParams) const
Calculates a space point whithout using the vertex.
Note
This is mostly to resolve space points from cosmic data
Note
The meaning of the parameter is explained in more detail in the function body
- Parameters
stripEnds1 – The ends of one strip
stripEnds2 – The ends of another strip
spParams – SpacePointParamaters for the SP
- Returns
parameter that indicates the location of the space point; returns
if it failed
-
Acts::Vector2 calcRhoZVars(const Acts::GeometryContext &gctx, const Measurement &measFront, const Measurement &measBack, const Vector3 &globalPos, const double theta) const
Calculate the rho and z covariance from the front and back measurement in the strip SP formation.
- Parameters
gctx – The current geometry context object, e.g. alignment
measFront – The measurement on the front layer
measBack – The measurement on the back layer
globalPos – global position
theta – The angle between the two strips
- Returns
(rho, z) components of the global covariance
-
Result<void> calculateStripSPPosition(const std::pair<Vector3, Vector3> &stripEnds1, const std::pair<Vector3, Vector3> &stripEnds2, const Vector3 &posVertex, SpacePointParameters &spParams, const double stripLengthTolerance) const
This function performs a straight forward calculation of a space point and returns whether it was succesful or not.
- Parameters
stripEnds1 – [in] Top and bottom end of the first strip
stripEnds2 – [in] Top and bottom end of the second strip
posVertex – [in] Position of the vertex
spParams – [inout] Data container of the calculations
stripLengthTolerance – [in] Tolerance scaling factor on the strip detector element length
- Returns
Result whether the space point calculation was succesful
-
Result<double> differenceOfMeasurementsChecked(const Vector3 &pos1, const Vector3 &pos2, const Vector3 &posVertex, const double maxDistance, const double maxAngleTheta2, const double maxAnglePhi2) const
Calculates (Delta theta)^2 + (Delta phi)^2 between two measurements.
- Parameters
pos1 – [in] position of the first measurement
pos2 – [in] position the second measurement
posVertex – [in] Position of the vertex
maxDistance – [in] Maximum distance between two measurements
maxAngleTheta2 – [in] Maximum squared theta angle between two measurements
maxAnglePhi2 – [in] Maximum squared phi angle between two measurements
- Returns
Result with the squared sum within configuration parameters.
-
std::pair<Vector3, Vector2> globalCoords(const GeometryContext &gctx, const Measurement &meas) const
Getter method for the global coordinates of a measurement.
- Parameters
gctx – The current geometry context object, e.g. alignment
meas – measurement that holds the necessary information
- Returns
vectors of the global coordinates and covariance of the measurement
-
Result<void> recoverSpacePoint(SpacePointParameters &spParams, double stripLengthGapTolerance) const
This function tests if a space point can be estimated by a more tolerant treatment of construction.
In fact, this function indirectly allows shifts of the vertex.
- Parameters
spParams – [in] container that stores geometric parameters and rules of the space point formation
stripLengthGapTolerance – [in] Tolerance scaling factor of the gap between strip detector elements
- Returns
indicator if the test was successful
-
Acts::Vector2 rhoZCovariance(const Acts::GeometryContext &gctx, const Acts::GeometryIdentifier &geoId, const Acts::Vector3 &globalPos, const Acts::SymMatrix2 &localCov) const
Get rho and z covariance from the local position and covariance.
- Parameters
gctx – The current geometry context object, e.g. alignment
geoId – The geometry ID
globalPos – The global position
localCov – The local covariance matrix
- Returns
(rho, z) components of the global covariance
-
using Measurement = Acts::BoundVariantMeasurement
-
template<typename ...extensions>
struct StepperExtensionList : private detail::Extendable<extensions...> - #include <Acts/Propagator/StepperExtensionList.hpp>
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)
- Template Parameters
extensions – Types of the extensions
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline bool finalize(propagator_state_t &state, const stepper_t &stepper, const double h, FreeMatrix &D) This functions broadcasts the call of the method finalize().
It collects all extensions and arguments and passes them forward for evaluation and returns a boolean.
-
template<typename propagator_state_t, typename stepper_t>
inline bool finalize(propagator_state_t &state, const stepper_t &stepper, const double h) This functions broadcasts the call of the method finalize().
It collects all extensions and arguments and passes them forward for evaluation and returns a boolean.
-
template<typename propagator_state_t, typename stepper_t>
inline bool k(const propagator_state_t &state, const stepper_t &stepper, Vector3 &knew, const Vector3 &bField, std::array<double, 4> &kQoP, const int i, const double h = 0., const Vector3 &kprev = Vector3::Zero()) This functions broadcasts the call for evaluating a generic k.
It collects all arguments and extensions, test their validity for the evaluation and passes them forward for evaluation and returns a boolean as indicator if the evaluation is valid.
-
template<typename propagator_state_t, typename stepper_t>
inline bool k1(const propagator_state_t &state, const stepper_t &stepper, Vector3 &knew, const Vector3 &bField, std::array<double, 4> &kQoP) This functions broadcasts the call for evaluating k1.
It collects all arguments and extensions, test their validity for the evaluation and passes them forward for evaluation and returns a boolean as indicator if the evaluation is valid.
-
template<typename propagator_state_t, typename stepper_t>
inline bool k2(const propagator_state_t &state, const stepper_t &stepper, Vector3 &knew, const Vector3 &bField, std::array<double, 4> &kQoP, const double h, const Vector3 &kprev) This functions broadcasts the call for evaluating k2.
It collects all arguments and extensions and passes them forward for evaluation and returns a boolean as indicator if the evaluation is valid.
-
template<typename propagator_state_t, typename stepper_t>
inline bool k3(const propagator_state_t &state, const stepper_t &stepper, Vector3 &knew, const Vector3 &bField, std::array<double, 4> &kQoP, const double h, const Vector3 &kprev) This functions broadcasts the call for evaluating k3.
It collects all arguments and extensions and passes them forward for evaluation and returns a boolean as indicator if the evaluation is valid.
-
template<typename propagator_state_t, typename stepper_t>
inline bool k4(const propagator_state_t &state, const stepper_t &stepper, Vector3 &knew, const Vector3 &bField, std::array<double, 4> &kQoP, const double h, const Vector3 &kprev) This functions broadcasts the call for evaluating k4.
It collects all arguments and extensions and passes them forward for evaluation and returns a boolean as indicator if the evaluation is valid.
-
template<typename propagator_state_t, typename stepper_t>
inline bool validExtensionForStep(const propagator_state_t &state, const stepper_t &stepper) Evaluation function to set valid extensions for an upcoming integration step.
- Template Parameters
propagator_state_t – Type of the state of the propagator
stepper_t – Type of the stepper
- Parameters
state – [in] State of the propagator
stepper – [in] Stepper of the propagation
-
class StraightLineStepper
- #include <Acts/Propagator/StraightLineStepper.hpp>
straight line stepper based on Surface intersection
The straight line stepper is a simple navigation stepper to be used to navigate through the tracking geometry. It can be used for simple material mapping, navigation validation
Public Types
-
using BField = NullBField
-
using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
-
using Covariance = BoundSymMatrix
-
using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>
-
using Jacobian = BoundMatrix
-
using state_type = State
Always use the same propagation state type, independently of the initial track parameter type and of the target surface.
Public Functions
-
StraightLineStepper() = default
-
Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Create and return the bound state at the current position.
It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator
- Parameters
state – [in] State that will be presented as
BoundState
surface – [in] The surface to which we bind the state
transportCov – [in] Flag steering covariance transport
freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound
- Returns
A bound state:
the parameters at the surface
the stepwise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline double charge(const State &state) const
Charge access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
CurvilinearState curvilinearState(State &state, bool transportCov = true) const
Create and return a curvilinear state at the current position.
This creates a curvilinear state.
- Parameters
state – [in] State that will be presented as
CurvilinearState
transportCov – [in] Flag steering covariance transport
- Returns
A curvilinear state:
the curvilinear parameters at given position
the stepweise jacobian towards it (from last bound)
and the path length (from start - for ordering)
-
inline Vector3 direction(const State &state) const
Momentum direction accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline Result<Vector3> getField(State &state, const Vector3 &pos) const
Get the field for the stepping, this gives back a zero field.
- Parameters
state – [inout] is the propagation state associated with the track the magnetic field cell is used (and potentially updated)
pos – [in] is the field position
-
inline double getStepSize(const State &state, ConstrainedStep::Type stype) const
Get the step size.
- Parameters
state – [in] The stepping state (thread-local cache)
stype – [in] The step size type to be returned
-
inline double momentum(const State &state) const
Absolute momentum accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline std::string outputStepSize(const State &state) const
Output the Step Size - single component.
- Parameters
state – [in,out] The stepping state (thread-local cache)
-
inline double overstepLimit(const State &state) const
Overstep limit.
- Parameters
state – The stepping state (thread-local cache)
-
inline Vector3 position(const State &state) const
Global particle position accessor.
- Parameters
state – [in] The stepping state (thread-local cache)
-
inline void releaseStepSize(State &state) const
Release the Step size.
- Parameters
state – [in,out] The stepping state (thread-local cache)
Resets the state.
- Parameters
state – [inout] State of the stepper
boundParams – [in] Parameters in bound parametrisation
cov – [in] Covariance matrix
surface – [in] The reset
State
will be on this surfacenavDir – [in] Navigation direction
stepSize – [in] Step size
-
inline void setStepSize(State &state, double stepSize, ConstrainedStep::Type stype = ConstrainedStep::actor, bool release = true) const
Set Step size - explicitely with a double.
- Parameters
state – [in,out] The stepping state (thread-local cache)
stepSize – [in] The step size value
stype – [in] The step size type to be set
release – [in] Do we release the step size?
-
template<typename propagator_state_t>
inline Result<double> step(propagator_state_t &state) const Perform a straight line propagation step.
- Parameters
state – [inout] is the propagation state associated with the track parameters that are being propagated. The state contains the desired step size, it can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.
- Returns
the step size taken
-
inline double time(const State &state) const
Time access.
- Parameters
state – [in] The stepping state (thread-local cache)
-
void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state - for the moment a dummy method.
Note
no check is done if the position is actually on the surface
- Template Parameters
surface_t – the surface type - ignored here
- Parameters
state – [inout] The stepper state
surface – [in] is the surface to which the covariance is forwarded to
freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound
-
void transportCovarianceToCurvilinear(State &state) const
Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state - for the moment a dummy method.
- Parameters
state – [inout] State of the stepper
-
void update(State &state, const FreeVector &freeParams, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const
Method to update a stepper state to the some parameters.
- Parameters
state – [inout] State object that will be updated
freeParams – [in] Free parameters that will be written into
state
boundParams – [in] Corresponding bound parameters used to update jacToGlobal in
state
covariance – [in] Covariance that willl be written into
state
surface – [in] The surface used to update the jacToGlobal
-
void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double up, double time) const
Method to update momentum, direction and p.
- Parameters
state – [inout] State object that will be updated
uposition – [in] the updated position
udirection – [in] the updated direction
up – [in] the updated momentum value
time – [in] the updated time value
-
template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, bool release = true) const Update step size.
It checks the status to the reference surface & updates the step size accordingly
- Parameters
state – [in,out] The stepping state (thread-local cache)
oIntersection – [in] The ObjectIntersection to layer, boundary, etc
release – [in] boolean to trigger step size release
-
inline Intersection3D::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck, LoggerWrapper logger = getDummyLogger()) const
Update surface status.
This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.
- Parameters
state – [inout] The stepping state (thread-local cache)
surface – [in] The surface provided
bcheck – [in] The boundary check for this status update
logger – [in] A logger instance
-
struct State
- #include <Acts/Propagator/StraightLineStepper.hpp>
State for track parameter propagation.
Public Functions
-
State() = delete
Constructor from the initial bound track parameters.
Note
the covariance matrix is copied when needed
- Template Parameters
charge_t – Type of the bound parameter charge
- Parameters
gctx – [in] is the context object for the geometry
mctx – [in] is the context object for the magnetic field
par – [in] The track parameters at start
ndir – [in] The navigation direction w.r.t momentum
ssize – [in] is the maximum step size
stolerance – [in] is the stepping tolerance
Public Members
-
Covariance cov = Covariance::Zero()
-
bool covTransport = false
Boolean to indiciate if you need covariance transport.
-
FreeVector derivative = FreeVector::Zero()
The propagation derivative.
-
std::reference_wrapper<const GeometryContext> geoContext
-
BoundToFreeMatrix jacToGlobal = BoundToFreeMatrix::Zero()
Jacobian from local to the global frame.
-
FreeMatrix jacTransport = FreeMatrix::Identity()
Pure transport jacobian part from runge kutta integration.
Navigation direction, this is needed for searching.
-
FreeVector pars = FreeVector::Zero()
Internal free vector parameters.
-
double pathAccumulated = 0.
accummulated path length state
-
double previousStepSize = 0.
-
double q = 1.
The charge as the free vector can be 1/p or q/p.
-
ConstrainedStep stepSize
adaptive step size of the runge-kutta integration
-
double tolerance = s_onSurfaceTolerance
The tolerance for the stepping.
-
State() = delete
-
using BField = NullBField
-
class StrawSurface : public Acts::LineSurface
- #include <Acts/Surfaces/StrawSurface.hpp>
Class for a StrawSurface in the TrackingGeometry to describe dirft tube and straw like detectors.
Public Functions
-
StrawSurface() = delete
-
~StrawSurface() override = default
-
inline virtual std::string name() const final
Return properly formatted class name for screen output */.
-
StrawSurface &operator=(const StrawSurface &other)
Assignment operator.
- Parameters
other – is the source surface for copying
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const final
Return a Polyhedron for the surfaces.
Note
if lseg is set to 1 then only the straw is created
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, it represents the full 2*M_PI coverange, if lseg is set to 1 only the extrema are given
- Returns
A list of vertices and a face/facett description of it
-
inline virtual SurfaceType type() const final
Return the surface type.
-
StrawSurface() = delete
-
class Surface : public virtual Acts::GeometryObject, public std::enable_shared_from_this<Surface>
- #include <Acts/Surfaces/Surface.hpp>
Abstract Base Class for tracking surfaces.
The Surface class builds the core of the Acts Tracking Geometry. All other geometrical objects are either extending the surface or are built from it.
Surfaces are either owned by Detector elements or the Tracking Geometry, in which case they are not copied within the data model objects.
Subclassed by Acts::ConeSurface, Acts::CylinderSurface, Acts::DiscSurface, Acts::LineSurface, Acts::PlaneSurface
Public Types
-
enum SurfaceType
This enumerator simplifies the persistency & calculations, by saving a dynamic_cast, e.g.
for persistency
Values:
-
enumerator Cone
-
enumerator Cylinder
-
enumerator Disc
-
enumerator Perigee
-
enumerator Plane
-
enumerator Straw
-
enumerator Curvilinear
-
enumerator Other
-
enumerator Cone
Public Functions
-
virtual ~Surface()
-
AlignmentToBoundMatrix alignmentToBoundDerivative(const GeometryContext &gctx, const FreeVector ¶meters, const FreeVector &pathDerivative) const
The derivative of bound track parameters w.r.t.
alignment parameters of its reference surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)
- Parameters
gctx – The current geometry context object, e.g. alignment change of alignment parameters
parameters – is the free parameters
pathDerivative – is the derivative of free parameters w.r.t. path length
- Returns
Derivative of bound track parameters w.r.t. local frame alignment parameters
-
virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)
Note
Re-implementation is needed for surface whose intersection with track is not its local xy plane, e.g. LineSurface, CylinderSurface and ConeSurface
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. the alignment parameters
Assign the surface material description.
The material is usually derived in a complicated way and loaded from a framework given source. As various surfaces may share the same source this is provided by a shared pointer
- Parameters
material – Material description associated to this surface
-
const DetectorElementBase *associatedDetectorElement() const
Return method for the associated Detector Element.
- Returns
plain pointer to the DetectorElement, can be nullptr
-
const Layer *associatedLayer() const
Return method for the associated Layer in which the surface is embedded.
- Returns
Layer by plain pointer, can be nullptr
-
void associateLayer(const Layer &lay)
Set Associated Layer Many surfaces can be associated to a Layer, but it might not be known yet during construction of the layer, this can be set afterwards.
- Parameters
lay – the assignment Layer by reference
-
virtual const SurfaceBounds &bounds() const = 0
Return method for SurfaceBounds.
- Returns
SurfaceBounds by reference
-
virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const BoundVector &boundParams) const
Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.
Note
In principle, the input could also be a free parameters vector as it could be transformed to a bound parameters. But the transform might fail in case the parameters is not on surface. To avoid the check inside this function, it takes directly the bound parameters as input (then the check might be done where this function is called).
- Parameters
gctx – The current geometry context object, e.g. alignment
boundParams – is the bound parameters vector
- Returns
Jacobian from local to global
-
virtual Vector3 center(const GeometryContext &gctx) const
Return method for the surface center by reference.
Note
the center is always recalculated in order to not keep a cache
- Parameters
gctx – The current geometry context object, e.g. alignment
- Returns
center position by value
-
virtual FreeToBoundMatrix freeToBoundJacobian(const GeometryContext &gctx, const FreeVector ¶meters) const
Calculate the jacobian from global to local which the surface knows best, hence the calculation is done here.
Note
It assumes the input free parameters is on surface, hence no onSurface check is done inside this function.
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Jacobian from global to local
-
virtual FreeToPathMatrix freeToPathDerivative(const GeometryContext &gctx, const FreeVector ¶meters) const
Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.
free parameters. The calculation is identical for all surfaces where the reference frame does not depend on the direction
- Parameters
gctx – The current geometry context object, e.g. alignment
parameters – is the free parameters
- Returns
Derivative of path length w.r.t. free parameters
Retrieve a
std::shared_ptr
for this surface (non-const version)Note
Will error if this was not created through the
makeShared
factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as abad_weak_ptr
exception), in C++17 it is defined as that exception.Note
Only call this if you need shared ownership of this object.
- Returns
The shared pointer
Retrieve a
std::shared_ptr
for this surface (const version)Note
Will error if this was not created through the
makeShared
factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as abad_weak_ptr
exception, in C++17 it is defined as that exception.Note
Only call this if you need shared ownership of this object.
- Returns
The shared pointer
-
virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, double tolerance = s_onSurfaceTolerance) const = 0
Global to local transformation Generalized global to local transformation for the surface types.
Since some surface types need the global momentum/direction to resolve sign ambiguity this is also provided
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
momentum – global 3D momentum representation (optionally ignored)
tolerance – optional tolerance within which a point is considered valid on surface
- Returns
a Result<Vector2> which can be !ok() if the operation fails
-
virtual bool insideBounds(const Vector2 &lposition, const BoundaryCheck &bcheck = true) const
The insideBounds method for local positions.
- Parameters
lposition – The local position to check
bcheck – BoundaryCheck directive for this onSurface check
- Returns
boolean indication if operation was successful
-
virtual SurfaceIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryCheck &bcheck) const = 0
Straight line intersection schema from position/direction.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position to start from
direction – The direction at start
bcheck – the Boundary Check
- Returns
SurfaceIntersection object (contains intersection & surface)
-
bool isOnSurface(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum, const BoundaryCheck &bcheck = true) const
The geometric onSurface method.
Geometrical check whether position is on Surface
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global position to be evaludated
momentum – global momentum (required for line-type surfaces)
bcheck – BoundaryCheck directive for this onSurface check
- Returns
boolean indication if operation was successful
-
virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const = 0
Calculate the derivative of bound track parameters local position w.r.t.
position in local 3D Cartesian coordinates
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position of the paramters in global
- Returns
Derivative of bound local position w.r.t. position in local 3D cartesian coordinates
-
virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &momentum) const = 0
Local to global transformation Generalized local to global transformation for the surface types.
Since some surface types need the global momentum/direction to resolve sign ambiguity this is also provided
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – local 2D position in specialized surface frame
momentum – global 3D momentum representation (optionally ignored)
- Returns
The global position by value
-
virtual std::string name() const = 0
Return properly formatted class name.
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0
Return method for the normal vector of the surface The normal vector can only be generally defined at a given local position It requires a local position to be given (in general)
- Parameters
gctx – The current geometry context object, e.g. alignment
lposition – is the local position where the normal vector is constructed
- Returns
normal vector by value
-
virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const
Return method for the normal vector of the surface The normal vector can only be generally defined at a given local position It requires a local position to be given (in general)
- Parameters
position – is the global position where the normal vector is constructed
gctx – The current geometry context object, e.g. alignment
- Returns
normal vector by value
-
inline virtual Vector3 normal(const GeometryContext &gctx) const
Return method for the normal vector of the surface.
It will return a normal vector at the center() position
- Parameters
gctx – The current geometry context object, e.g. alignment
- Returns
normal vector by value
-
virtual bool operator!=(const Surface &sf) const
Comparison (non-equality) operator.
- Parameters
sf – Source surface for the comparison
-
Surface &operator=(const Surface &other)
Assignment operator.
Note
copy construction invalidates the association to detector element and layer
- Parameters
other – Source surface for the assignment
-
virtual bool operator==(const Surface &other) const
Comparison (equality) operator The strategy for comparison is (a) first pointer comparison (b) then type comparison (c) then bounds comparison (d) then transform comparison.
- Parameters
other – source surface for the comparison
-
virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const = 0
Calucation of the path correction for incident.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
direction – global 3D momentum direction
- Returns
Path correction with respect to the nominal incident.
-
virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, size_t lseg) const = 0
Return a Polyhedron for this object.
Note
An internal surface transform can invalidate the extrema in the transformed space
- Parameters
gctx – The current geometry context object, e.g. alignment
lseg – Number of segments along curved lines, if the lseg is set to one, only the corners and the extrema are given, otherwise it represents the number of segments for a full 2*M_PI circle and is scaled to the relevant sector
- Returns
A list of vertices and a face/facett description of it
-
virtual Acts::RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &momentum) const
Return mehtod for the reference frame This is the frame in which the covariance matrix is defined (specialized by all surfaces)
- Parameters
gctx – The current geometry context object, e.g. alignment
position – global 3D position - considered to be on surface but not inside bounds (check is done)
momentum – global 3D momentum representation (optionally ignored)
- Returns
RotationMatrix3 which defines the three axes of the measurement frame
-
const ISurfaceMaterial *surfaceMaterial() const
Return method for the associated Material to this surface.
- Returns
SurfaceMaterial as plain pointer, can be nullptr
Return method for the shared pointer to the associated Material.
- Returns
SurfaceMaterial as shared_pointer, can be nullptr
-
virtual std::ostream &toStream(const GeometryContext &gctx, std::ostream &sl) const
Output Method for std::ostream, to be overloaded by child classes.
- Parameters
gctx – The current geometry context object, e.g. alignment
sl – is the ostream to be dumped into
-
virtual const Transform3 &transform(const GeometryContext &gctx) const
Return method for the surface Transform3 by reference In case a detector element is associated the surface transform is just forwarded to the detector element in order to keep the (mis-)alignment cache cetrally handled.
- Parameters
gctx – The current geometry context object, e.g. alignment
- Returns
the contextual transform
-
virtual SurfaceType type() const = 0
Return method for the Surface type to avoid dynamic casts.
Public Static Functions
Factory for producing memory managed instances of Surface.
Will forward all parameters and will attempt to find a suitable constructor.
-
enum SurfaceType
-
class SurfaceArray
- #include <Acts/Surfaces/SurfaceArray.hpp>
Provides Surface binning in N dimensions.
Uses
Grid
under the hood to implement the storage and lookup Contains a lookup struct which talks to theGrid
and performs utility actions. This struct needs to be initialised externally and passed toSurfaceArray
on construction.Public Functions
Default constructor which takes a
SurfaceLookup
and a vector of surfaces.- Parameters
gridLookup – The grid storage.
SurfaceArray
does not fill it on its ownsurfaces – The input vector of surfaces. This is only for bookkeeping, so we can ask
transform – Optional additional transform for this SurfaceArray
Constructor with a single surface.
- Parameters
srf – The one and only surface
-
inline SurfaceVector &at(const Vector3 &position)
Get all surfaces in bin given by position.
- Parameters
position – the lookup position
- Returns
reference to
SurfaceVector
contained in bin at that position
-
inline const SurfaceVector &at(const Vector3 &position) const
Get all surfaces in bin given by position
pos
.- Parameters
position – the lookup position
- Returns
const reference to
SurfaceVector
contained in bin at that position
-
inline SurfaceVector &at(size_t bin)
Get all surfaces in bin given by global bin index
bin
.- Parameters
bin – the global bin index
- Returns
reference to
SurfaceVector
contained in bin
-
inline const SurfaceVector &at(size_t bin) const
Get all surfaces in bin given by global bin index.
- Parameters
bin – the global bin index
- Returns
const reference to
SurfaceVector
contained in bin
-
inline std::vector<BinningValue> binningValues() const
The binning values described by this surface grid lookup They are in order of the axes.
-
inline std::vector<const IAxis*> getAxes() const
Get vector of axes spanning the grid as
AnyAxis
.Note
The axes in the vector are copies. Only use for introspection and querying.
- Returns
vector of
AnyAxis
-
inline Vector3 getBinCenter(size_t bin)
Get the center of the bin identified by global bin index
bin
.- Parameters
bin – the global bin index
- Returns
Center position of the bin in global coordinates
-
inline bool isValidBin(size_t bin) const
Checks if global bin is valid.
Note
Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.
- Parameters
bin – the global bin index
- Returns
bool if the bin is valid
-
inline const SurfaceVector &neighbors(const Vector3 &position) const
Get all surfaces in bin at
pos
and its neighbors.Note
The
SurfaceVector
will be combined. For technical reasons, the different bin content vectors have to be copied, so the resulting vector contains copies.- Parameters
position – The position to lookup as nominal
- Returns
Merged
SurfaceVector
of neighbors and nominal
-
inline size_t size() const
Get the size of the underlying grid structure including under/overflow bins.
- Returns
the size
-
inline const SurfaceVector &surfaces() const
Get all surfaces attached to this
SurfaceArray
.Note
This does not reflect the actual state of the grid. It only returns what was given in the constructor, without any checks if that is actually whats in the grid.
- Returns
Reference to
SurfaceVector
containing all surfaces
-
std::ostream &toStream(const GeometryContext &gctx, std::ostream &sl) const
String representation of this
SurfaceArray
.- Parameters
gctx – The current geometry context object, e.g. alignment
sl – Output stream to write to
- Returns
the output stream given as
sl
-
inline const Transform3 &transform() const
-
struct ISurfaceGridLookup
- #include <Acts/Surfaces/SurfaceArray.hpp>
Base interface for all surface lookups.
Subclassed by Acts::SurfaceArray::SingleElementLookup, Acts::SurfaceArray::SurfaceGridLookup< Axes >
Public Functions
-
virtual ~ISurfaceGridLookup() = 0
Pure virtual destructor.
-
inline virtual std::vector<BinningValue> binningValues() const
The binning values described by this surface grid lookup They are in order of the axes (optional) and empty for eingle lookups.
-
virtual size_t completeBinning(const GeometryContext &gctx, const SurfaceVector &surfaces) = 0
Attempts to fix sub-optimal binning by filling closest Surfaces into empty bin.
- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – The surface pointers to fill
- Returns
number of bins that were filled
-
virtual size_t dimensions() const = 0
Get the number of dimensions of the grid.
- Returns
number of dimensions
-
virtual void fill(const GeometryContext &gctx, const SurfaceVector &surfaces) = 0
Fill provided surfaces into the contained
Grid
.- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – Input surface pointers
-
virtual std::vector<const IAxis*> getAxes() const = 0
Returns copies of the axes used in the grid as
AnyAxis
.Note
This returns copies. Use for introspection and querying.
- Returns
The axes
-
virtual Vector3 getBinCenter(size_t bin) const = 0
Gets the center position of bin
bin
in global coordinates.- Parameters
bin – the global bin index
- Returns
The bin center
-
virtual bool isValidBin(size_t bin) const = 0
Checks if global bin is valid.
Note
Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.
- Parameters
bin – the global bin index
- Returns
bool if the bin is valid
-
virtual SurfaceVector &lookup(const Vector3 &position) = 0
Performs lookup at
pos
and returns bin content as reference.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin
-
virtual const SurfaceVector &lookup(const Vector3 &position) const = 0
Performs lookup at
pos
and returns bin content as const reference.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin
-
virtual SurfaceVector &lookup(size_t bin) = 0
Performs lookup at global bin and returns bin content as reference.
- Parameters
bin – Global lookup bin
- Returns
SurfaceVector
at given bin
-
virtual const SurfaceVector &lookup(size_t bin) const = 0
Performs lookup at global bin and returns bin content as const reference.
- Parameters
bin – Global lookup bin
- Returns
SurfaceVector
at given bin
-
virtual const SurfaceVector &neighbors(const Vector3 &position) const = 0
Performs a lookup at
pos
, but returns neighbors as well.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin. Copy of all bins selected
-
virtual size_t size() const = 0
Returns the total size of the grid (including under/overflow bins)
- Returns
Size of the grid data structure
-
virtual ~ISurfaceGridLookup() = 0
-
struct SingleElementLookup : public Acts::SurfaceArray::ISurfaceGridLookup
- #include <Acts/Surfaces/SurfaceArray.hpp>
Lookup implementation which wraps one element and always returns this element when lookup is called.
Public Functions
-
inline SingleElementLookup(SurfaceVector::value_type element)
Default constructor.
- Parameters
element – the one and only element.
-
inline virtual size_t completeBinning(const GeometryContext&, const SurfaceVector&) override
Comply with concept and provide completeBinning method.
Note
Does nothing
-
inline virtual size_t dimensions() const override
Get the number of dimensions.
- Returns
always 0
-
inline virtual void fill(const GeometryContext&, const SurfaceVector&) override
Comply with concept and provide fill method.
Note
Does nothing
-
inline virtual std::vector<const IAxis*> getAxes() const override
Returns an empty vector of
AnyAxis
.- Returns
empty vector
-
inline virtual Vector3 getBinCenter(size_t bin) const override
Gets the bin center, but always returns (0, 0, 0)
- Parameters
bin – is ignored
- Returns
(0, 0, 0)
-
inline virtual bool isValidBin(size_t bin) const override
Returns if the bin is valid (it is)
- Parameters
bin – is ignored
- Returns
always true
-
inline virtual SurfaceVector &lookup(const Vector3 &position) override
Lookup, always returns
element
.- Parameters
position – is ignored
- Returns
reference to vector containing only
element
-
inline virtual const SurfaceVector &lookup(const Vector3 &position) const override
Lookup, always returns
element
.- Parameters
position – is ignored
- Returns
reference to vector containing only
element
-
inline virtual SurfaceVector &lookup(size_t bin) override
Lookup, always returns
element
.- Parameters
bin – is ignored
- Returns
reference to vector containing only
element
-
inline virtual const SurfaceVector &lookup(size_t bin) const override
Lookup, always returns
element
.- Parameters
bin – is ignored
- Returns
reference to vector containing only
element
-
inline virtual const SurfaceVector &neighbors(const Vector3 &position) const override
Lookup, always returns
element
.- Parameters
position – is ignored
- Returns
reference to vector containing only
element
-
inline virtual size_t size() const override
returns 1
- Returns
1
-
inline SingleElementLookup(SurfaceVector::value_type element)
-
template<class ...Axes>
struct SurfaceGridLookup : public Acts::SurfaceArray::ISurfaceGridLookup - #include <Acts/Surfaces/SurfaceArray.hpp>
Lookup helper which encapsulates a
Grid
.- Template Parameters
Axes – The axes used for the grid
Public Types
-
using Grid_t = detail::Grid<SurfaceVector, Axes...>
-
using point_t = std::conditional_t<DIM == 1, std::array<double, 1>, ActsVector<DIM>>
Specifies the local coordinate type.
This resolves to
ActsVector<DIM>
for DIM > 1, elsestd::array<double, 1>
Public Functions
-
inline SurfaceGridLookup(std::function<point_t(const Vector3&)> globalToLocal, std::function<Vector3(const point_t&)> localToGlobal, std::tuple<Axes...> axes, std::vector<BinningValue> bValues = {})
Default constructor.
Note
Signature of localToGlobal and globalToLocal depends on
DIM
. If DIM > 1, local coords areActsVector<DIM>
elsestd::array<double, 1>
.- Parameters
globalToLocal – Callable that converts from global to local
localToGlobal – Callable that converts from local to global
axes – The axes to build the grid data structure.
bValues – What the axes represent (optional)
-
inline virtual std::vector<BinningValue> binningValues() const override
The binning values described by this surface grid lookup They are in order of the axes.
-
inline virtual size_t completeBinning(const GeometryContext &gctx, const SurfaceVector &surfaces) override
Attempts to fix sub-optimal binning by filling closest Surfaces into empty bins.
Note
This does not always do what you want.
- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – The surface pointers to fill
- Returns
number of bins that were filled
-
inline virtual size_t dimensions() const override
Get the number of dimensions of the grid.
- Returns
number of dimensions
-
inline virtual void fill(const GeometryContext &gctx, const SurfaceVector &surfaces) override
Fill provided surfaces into the contained
Grid
.This is done by iterating, accessing the binningPosition, lookup and append. Also populates the neighbor map by combining the filled bins of all bins around a given one.
- Parameters
gctx – The current geometry context object, e.g. alignment
surfaces – Input surface pointers
-
inline virtual std::vector<const IAxis*> getAxes() const override
Returns copies of the axes used in the grid as
AnyAxis
.Note
This returns copies. Use for introspection and querying.
- Returns
The axes
-
inline virtual Vector3 getBinCenter(size_t bin) const override
Gets the center position of bin
bin
in global coordinates.- Parameters
bin – the global bin index
- Returns
The bin center
-
inline virtual bool isValidBin(size_t bin) const override
Checks if global bin is valid.
Note
Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.
- Parameters
bin – the global bin index
- Returns
bool if the bin is valid
-
inline virtual SurfaceVector &lookup(const Vector3 &position) override
Performs lookup at
pos
and returns bin content as reference.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin
-
inline virtual const SurfaceVector &lookup(const Vector3 &position) const override
Performs lookup at
pos
and returns bin content as const reference.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin
-
inline virtual SurfaceVector &lookup(size_t bin) override
Performs lookup at global bin and returns bin content as reference.
- Parameters
bin – Global lookup bin
- Returns
SurfaceVector
at given bin
-
inline virtual const SurfaceVector &lookup(size_t bin) const override
Performs lookup at global bin and returns bin content as const reference.
- Parameters
bin – Global lookup bin
- Returns
SurfaceVector
at given bin
-
inline virtual const SurfaceVector &neighbors(const Vector3 &position) const override
Performs a lookup at
pos
, but returns neighbors as well.- Parameters
position – Lookup position
- Returns
SurfaceVector
at given bin. Copy of all bins selected
-
inline virtual size_t size() const override
Returns the total size of the grid (including under/overflow bins)
- Returns
Size of the grid data structure
Public Static Attributes
-
static constexpr size_t DIM = sizeof...(Axes)
-
class SurfaceArrayCreator
- #include <Acts/Geometry/SurfaceArrayCreator.hpp>
It is designed create sub surface arrays to be ordered on Surfaces.
Public Functions
-
inline SurfaceArrayCreator(std::unique_ptr<const Logger> logger = getDefaultLogger("SurfaceArrayCreator", Logging::INFO))
Constructor with default config.
- Parameters
logger – logging instance
-
inline SurfaceArrayCreator(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("SurfaceArrayCreator", Logging::INFO))
Constructor with explicit config.
- Parameters
cfg – Explicit config struct
logger – logging instance
-
virtual ~SurfaceArrayCreator() = default
Destructor.
-
inline void setLogger(std::unique_ptr<const Logger> logger)
Set logging instance.
- Parameters
logger – is the logging instance to be set
SurfaceArrayCreator interface method.
create an array in a cylinder, binned in phi, z when extremas and bin numbers are known
Warning
This function requires the cylinder aligned with the z-axis
- Parameters
surfaces – is the vector of pointers to sensitive surfaces to be ordered on the cylinder
gctx – [in] The gometry context fro this building call
protoLayerOpt – The proto layer containing the layer size
binsPhi – is the number of bins in phi for the surfaces
binsZ – is the number of bin in Z for the surfaces
transform – is the (optional) additional transform applied
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
a unique pointer to a new SurfaceArray
SurfaceArrayCreator interface method.
create an array in a cylinder, binned in phi, z when extremas and bin numbers are unknown - this method goes through the surfaces and finds out the needed information
Warning
This function requires the cylinder aligned with the z-axis
- Parameters
surfaces – is the vector of pointers to sensitive surfaces to be ordered on the cylinder
gctx – [in] The gometry context fro this building call
protoLayerOpt – The proto layer containing the layer size
bTypePhi – the binning type in phi direction (equidistant/aribtrary)
bTypeZ – the binning type in z direction (equidistant/aribtrary)
transform – is the (optional) additional transform applied
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
a unique pointer a new SurfaceArray
SurfaceArrayCreator interface method.
create an array on a disc, binned in r, phi when extremas and bin numbers are known
Warning
This function requires the disc aligned with the z-axis
- Parameters
surfaces – is the vector of pointers to sensitive surfaces to be ordered on the disc
gctx – [in] The gometry context fro this building call
protoLayerOpt – The proto layer containing the layer size
binsPhi – is the number of bins in phi for the surfaces
binsR – is the number of bin in R for the surfaces
transform – is the (optional) additional transform applied
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
a unique pointer a new SurfaceArray
SurfaceArrayCreator interface method.
create an array in a cylinder, binned in phi, r when extremas and bin numbers are unknown - this method goes through the surfaces and finds out the needed information
Note
If there is more than on R-Ring, number of phi bins will be set to lowest number of surfaces of any R-ring. This ignores bTypePhi and produces equidistant binning in phi
Warning
This function requires the disc aligned with the z-axis
- Parameters
surfaces – is the vector of pointers to sensitive surfaces to be ordered on the disc
gctx – [in] The gometry context fro this building call
protoLayerOpt – The proto layer containing the layer size
bTypeR – the binning type in r direction (equidistant/aribtrary)
bTypePhi – the binning type in phi direction (equidistant/aribtrary)
transform – is the (optional) additional transform applied
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
a unique pointer a new SurfaceArray
SurfaceArrayCreator interface method.
create an array on a plane
Warning
This function requires the plane aligned with either the x-, y- or z-axis
- Parameters
gctx – [in] The gometry context fro this building call
surfaces – [in] is the vector of pointers to sensitive surfaces to be ordered on the plane
bins1 – [in] is the number of bins in the orthogonal direction to
bValue
bins2 – [in] is the number of bins in the orthogonal direction to
bValue
bValue – [in] Direction of the aligned surfaces
protoLayerOpt – [in] Optional
ProtoLayer
instancetransform – [in] is the (optional) additional transform applied
- Pre
the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed
- Returns
a unique pointer a new SurfaceArray
Public Static Functions
-
static inline bool isSurfaceEquivalent(const GeometryContext &gctx, BinningValue bValue, const Surface *a, const Surface *b)
Static check funtion for surface equivalent.
- Parameters
gctx – [in] the geometry context for this check
bValue – the binning value for the binning
a – first surface for checking
b – second surface for checking
Friends
- friend class Acts::SurfaceArray
- friend struct Acts::Test::SurfaceArrayCreatorFixture
-
struct Config
- #include <Acts/Geometry/SurfaceArrayCreator.hpp>
Public Members
-
bool doPhiBinningOptimization = true
Optimize the binning in phi for disc layers.
Reduces the number of bins to the lowest number of non-equivalent phi surfaces of all r-bins. If false, this step is skipped.
-
SurfaceMatcher surfaceMatcher = SurfaceArrayCreator::isSurfaceEquivalent
Type-erased function which determines whether two surfaces are supposed to be considered equivalent in terms of the binning.
-
bool doPhiBinningOptimization = true
-
struct ProtoAxis
- #include <Acts/Geometry/SurfaceArrayCreator.hpp>
Public Functions
-
inline size_t getBin(AxisScalar x) const
Public Members
-
std::vector<AxisScalar> binEdges
-
BinningType bType
-
BinningValue bValue
-
AxisScalar max
-
AxisScalar min
-
size_t nBins
-
inline size_t getBin(AxisScalar x) const
-
inline SurfaceArrayCreator(std::unique_ptr<const Logger> logger = getDefaultLogger("SurfaceArrayCreator", Logging::INFO))
-
struct SurfaceBinningMatcher
- #include <Acts/Geometry/SurfaceBinningMatcher.hpp>
Public Types
-
using Range = std::pair<double, double>
The binning tolerance parameters.
Public Functions
-
SurfaceBinningMatcher() = default
-
inline SurfaceBinningMatcher(const std::vector<Range> &tolpars)
-
inline bool operator()(const Acts::GeometryContext &gctx, Acts::BinningValue bValue, const Acts::Surface *one, const Acts::Surface *other) const
Check function for surface equivalent.
- Parameters
gctx – [in] gctx the geometry context for this check
bValue – the binning value for the binning
one – first surface for checking
other – second surface for checking
-
using Range = std::pair<double, double>
-
class SurfaceBounds
- #include <Acts/Surfaces/SurfaceBounds.hpp>
Interface for surface bounds.
Surface bounds provide:
inside() checks
distance to boundary calculations
the BoundsType and a set of parameters to simplify persistency
Subclassed by Acts::ConeBounds, Acts::CylinderBounds, Acts::DiscBounds, Acts::InfiniteBounds, Acts::LineBounds, Acts::PlanarBounds
Public Types
-
enum BoundsType
This is nested to the SurfaceBounds, as also VolumeBounds will have Bounds Type.
Values:
-
enumerator eCone
-
enumerator eCylinder
-
enumerator eDiamond
-
enumerator eDisc
-
enumerator eEllipse
-
enumerator eLine
-
enumerator eRectangle
-
enumerator eTrapezoid
-
enumerator eTriangle
-
enumerator eDiscTrapezoid
-
enumerator eConvexPolygon
-
enumerator eAnnulus
-
enumerator eBoundless
-
enumerator eOther
-
enumerator eCone
Public Functions
-
virtual ~SurfaceBounds() = default
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const = 0
Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
virtual std::ostream &toStream(std::ostream &os) const = 0
Output Method for std::ostream, to be overloaded by child classes.
- Parameters
os – is the outstream in which the string dump is done
-
virtual BoundsType type() const = 0
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
virtual std::vector<double> values() const = 0
Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.
- Returns
of the stored values for this SurfaceBounds object
-
template<typename Selector = SurfaceSelector>
struct SurfaceCollector - #include <Acts/Propagator/SurfaceCollector.hpp>
A Surface Collector struct templated with a Selector type.
Whenever a surface is passed in the propagation that satisfies the selector, it is recorded for further usage in the flow.
Public Types
-
using result_type = this_result
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t &state, const stepper_t &stepper, result_type &result) const Collector action for the ActionList of the Propagator It checks if the propagator state has a current surface, in which case the action is performed:
it records the surface given the configuration
- Template Parameters
propagator_state_t – is the type of Propagator state
stepper_t – Type of the stepper used for the propagation
- Parameters
state – [inout] is the mutable stepper state object
stepper – [in] The stepper in use
result – [inout] is the mutable result object
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t&, const stepper_t&) const Pure observer interface.
this does not apply to the surface collector
Public Members
-
Selector selector
The selector used for this surface.
-
struct this_result
- #include <Acts/Propagator/SurfaceCollector.hpp>
Simple result struct to be returned It has all the SurfaceHit objects that are collected (and thus have been selected)
Public Members
-
std::vector<SurfaceHit> collected
-
std::vector<SurfaceHit> collected
-
using result_type = this_result
-
struct SurfaceHit
- #include <Acts/Propagator/SurfaceCollector.hpp>
The information to be writtern out per hit surface.
-
class SurfaceMaterialMapper
- #include <Acts/Material/SurfaceMaterialMapper.hpp>
SurfaceMaterialMapper.
This is the main feature tool to map material information from a 3D geometry onto the TrackingGeometry with its surface material description.
The process runs as such:
1) TrackingGeometry is parsed and for each Surface with ProtoSurfaceMaterial a local store is initialized the identification is done hereby through the Surface::GeometryIdentifier
2) A Cache is generated that is used to keep the filling thread local, the filling is protected with std::mutex
3) A number of N material tracks is read in, each track has : origin, direction, material steps < position, step length, x0, l0, a, z, rho >
for each track: surfaces along the origin/direction path are collected the closest material steps are assigned
4) Each ‘hit’ bin per event is counted and averaged at the end of the run
Public Types
-
using StraightLinePropagator = Propagator<StraightLineStepper, Navigator>
Public Functions
-
SurfaceMaterialMapper() = delete
Delete the Default constructor.
-
SurfaceMaterialMapper(const Config &cfg, StraightLinePropagator propagator, std::unique_ptr<const Logger> slogger = getDefaultLogger("SurfaceMaterialMapper", Logging::INFO))
Constructor with config object.
- Parameters
cfg – Configuration struct
propagator – The straight line propagator
slogger – The logger
-
State createState(const GeometryContext &gctx, const MagneticFieldContext &mctx, const TrackingGeometry &tGeometry) const
helper method that creates the cache for the mapping
This method takes a TrackingGeometry, finds all surfaces with material proxis and returns you a Cache object tO be used
- Parameters
gctx – [in] The geometry context to use
mctx – [in] The magnetic field context to use
tGeometry – [in] The geometry which should be mapped
-
void finalizeMaps(State &mState) const
Method to finalize the maps.
It calls the final run averaging and then transforms the AccumulatedSurface material class to a surface material class type
- Parameters
mState –
-
void mapInteraction(State &mState, RecordedMaterialTrack &mTrack) const
Loop through all the material interactions and add them to the associated surface.
- Parameters
mState – The current state map
mTrack – The material track to be mapped
-
void mapMaterialTrack(State &mState, RecordedMaterialTrack &mTrack) const
Process/map a single track.
Note
the RecordedMaterialSlab of the track are assumed to be ordered from the starting position along the starting direction
- Parameters
mState – The current state map
mTrack – The material track to be mapped
-
void mapSurfaceInteraction(State &mState, std::vector<MaterialInteraction> &rMaterial) const
Loop through all the material interactions and add them to the associated surface.
Note
The material interactions are assumed to have an associated surface ID
- Parameters
mState – The current state map
rMaterial – Vector of all the material interactions that will be mapped
-
struct Config
- #include <Acts/Material/SurfaceMaterialMapper.hpp>
Nested Configuration struct for the material mapper.
Public Members
-
bool computeVariance = false
Compute the variance of each material slab (only if using an input map)
-
bool emptyBinCorrection = true
Correct for empty bins (recommended)
-
std::array<double, 2> etaRange = {{-6., 6.}}
Mapping range.
-
bool mapperDebugOutput = false
Mapping output to debug stream.
-
bool computeVariance = false
-
struct State
- #include <Acts/Material/SurfaceMaterialMapper.hpp>
Nested State struct which is used for the mapping prococess.
Public Functions
-
inline State(const GeometryContext &gctx, const MagneticFieldContext &mctx)
- Parameters
gctx – [in] The geometry context to use
mctx – [in] The magnetic field context to use
Public Members
-
std::map<GeometryIdentifier, AccumulatedSurfaceMaterial> accumulatedMaterial
The accumulated material per geometry ID.
-
std::reference_wrapper<const GeometryContext> geoContext
Reference to the geometry context for the mapping.
-
std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>> inputSurfaceMaterial
The surface material of the input tracking geometry.
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
Reference to the magnetic field context.
-
std::map<GeometryIdentifier, std::unique_ptr<const ISurfaceMaterial>> surfaceMaterial
The created surface material from it.
-
std::map<GeometryIdentifier, std::shared_ptr<const IVolumeMaterial>> volumeMaterial
The volume material of the input tracking geometry.
-
inline State(const GeometryContext &gctx, const MagneticFieldContext &mctx)
-
using StraightLinePropagator = Propagator<StraightLineStepper, Navigator>
-
struct SurfaceReached
- #include <Acts/Propagator/StandardAborters.hpp>
This is the condition that the Surface has been reached it then triggers an propagation abort of the propagation.
Public Functions
-
SurfaceReached() = default
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] Stepper used for propagation
-
template<typename propagator_state_t, typename stepper_t>
inline bool operator()(propagator_state_t &state, const stepper_t &stepper, const Surface &targetSurface) const boolean operator for abort condition without using the result
- Template Parameters
propagator_state_t – Type of the propagator state
stepper_t – Type of the stepper
- Parameters
state – [inout] The propagation state object
stepper – [in] Stepper used for the progation
targetSurface – [in] The target surface
-
SurfaceReached() = default
-
struct SurfaceSelector
- #include <Acts/Propagator/SurfaceCollector.hpp>
Simple struct to select surfaces.
Public Functions
-
inline SurfaceSelector(bool sSensitive = true, bool sMaterial = false, bool sPassive = false)
SurfaceSelector with options.
- Parameters
sSensitive – is the directive to select sensitive surfaces
sMaterial – is the directive to select material surfaces
sPassive – is the directive to select passive surfaces
Public Members
-
bool selectMaterial = false
-
bool selectPassive = false
-
bool selectSensitive = true
-
inline SurfaceSelector(bool sSensitive = true, bool sMaterial = false, bool sPassive = false)
-
struct TargetOptions
- #include <Acts/Propagator/StandardAborters.hpp>
TargetOptions struct for geometry interface.
Public Functions
create target options
Public Members
-
BoundaryCheck boundaryCheck = false
Target Boundary check directive - always false here.
Navigation direction.
-
double pathLimit = std::numeric_limits<double>::max()
The path limit.
-
const Surface *startObject = nullptr
Object to check against - always nullptr here.
-
class TGeoCylinderDiscSplitter : public Acts::ITGeoDetectorElementSplitter
- #include <Acts/Plugins/TGeo/TGeoCylinderDiscSplitter.hpp>
TGeoCylinderDiscSplitter.
Split Cylinder and disks into submodules
Public Functions
-
TGeoCylinderDiscSplitter(const Config &cfg, std::unique_ptr<const Acts::Logger> logger = Acts::getDefaultLogger("TGeoCylinderDiscSplitter", Acts::Logging::INFO))
Constructor.
- Parameters
cfg – the configuration struct
logger – the logging object
-
virtual ~TGeoCylinderDiscSplitter() = default
Take a geometry context and TGeoElement and split it into sub elements.
Note
If no split is performed the unsplit detector element is returned
- Parameters
gctx – is a geometry context object
tgde – is a TGeoDetectorElement that is eventually split
- Returns
a vector of TGeoDetectorElement objects
-
struct Config
- #include <Acts/Plugins/TGeo/TGeoCylinderDiscSplitter.hpp>
Nested configuration struct.
Public Members
-
int cylinderLongitudinalSegments = -1
Number of segments in r for a disk.
-
int cylinderPhiSegments = -1
Number of segments in phi for a disc.
-
int discPhiSegments = -1
Number of segments in phi for a disc.
-
int discRadialSegments = -1
Number of segments in r for a disk.
-
int cylinderLongitudinalSegments = -1
-
TGeoCylinderDiscSplitter(const Config &cfg, std::unique_ptr<const Acts::Logger> logger = Acts::getDefaultLogger("TGeoCylinderDiscSplitter", Acts::Logging::INFO))
-
class TGeoDetectorElement : public Acts::IdentifiedDetectorElement
- #include <Acts/Plugins/TGeo/TGeoDetectorElement.hpp>
DetectorElement plugin for ROOT TGeo shapes.
Added possibility to hand over transformation matrix.
Subclassed by Acts::DD4hepDetectorElement
Public Types
-
using ContextType = GeometryContext
Broadcast the context type.
Public Functions
Constructor.
Note
this constructor used auto-translation
Note
This parameter only needs to be set for plane modules
Note
In the translation from a 3D geometry (TGeo) which only knows tubes to a 2D geometry (Tracking geometry) a distinction if the module should be described as a cylinder or a disc surface needs to be done. Since this information can not be taken just from the geometry description (both can be described as TGeoTubeSeg), one needs to set the flag ‘isDisc’ in case a volume with shape
TGeoTubeSeg
should be translated to a disc surface. Per default it will be translated into a cylindrical surface.- Parameters
identifier – is the detector identifier
tGeoNode – is the TGeoNode which should be represented
tGeoMatrix – The Matrix to global (i.e. ACTS transform)
axes – is the axis orientation with respect to the tracking frame it is a string of the three characters x, y and z (standing for the three axes) there is a distinction between capital and lower case characters :
capital -> positive orientation of the axis
lower case -> negative orientation of the axis example options are “XYZ” -> identical frame definition (default value) “YZX” -> node y axis is tracking x axis, etc. “XzY” -> negative node z axis is tracking y axis, etc.
scalor – is the scale factor for unit conversion if needed
material – Possible material of detector element
Constructor with pre-computed surface.
Note
this detector element constructor needs everything pre-computed.
- Parameters
identifier – is the detector identifier
tGeoNode – is the TGeoNode which should be represented
tgTransform – the transform of this detector element
tgBounds – the bounds of this surface
tgThickness – the thickness of this detector element
Constructor with pre-computed disk surface.
Note
this detector element constructor needs everything pre-computed.
- Parameters
identifier – is the detector identifier
tGeoNode – is the TGeoNode which should be represented
tgTransform – the transform of this detector element
tgBounds – the bounds of this surface
tgThickness – the thickness of this detector element
-
~TGeoDetectorElement() override
-
inline virtual const std::shared_ptr<const DigitizationModule> digitizationModule() const final
Retrieve the DigitizationModule.
-
inline virtual Identifier identifier() const final
Retrieve the Identifier.
-
inline const Surface &surface() const override
Return surface associated with this identifier, which should come from the.
-
inline const TGeoNode &tgeoNode() const
Return the TGeoNode for back navigation.
-
inline double thickness() const override
Returns the thickness of the module.
-
inline const Transform3 &transform(const GeometryContext &gctx) const override
Return local to global transform associated with this identifier.
- Parameters
gctx – The current geometry context object, e.g. alignment
-
using ContextType = GeometryContext
-
class TGeoLayerBuilder : public Acts::ILayerBuilder
- #include <Acts/Plugins/TGeo/TGeoLayerBuilder.hpp>
This parses the gGeoManager and looks for a defined combination of volume with contained sensitive detector element.
The association is done by matching the names of the TGeoNode / TGeoVolume to the search string.
The parsing can be restricted to a given parse volume (in r and z), and given some splitting parameters the surfaces can be automatically be split into layers.
Public Types
-
using ElementFactory = std::function<std::shared_ptr<TGeoDetectorElement>(const Identifier&, const TGeoNode&, const TGeoMatrix &tGeoMatrix, const std::string &axes, double scalor, std::shared_ptr<const Acts::ISurfaceMaterial> material)>
Public Functions
-
TGeoLayerBuilder(const Config &config, std::unique_ptr<const Logger> logger = getDefaultLogger("TGeoLayerBuilder", Logging::INFO))
Constructor.
- Parameters
config – is the configuration struct
logger – the local logging instance
-
~TGeoLayerBuilder() override
Destructor.
-
virtual const LayerVector centralLayers(const GeometryContext &gctx) const final
LayerBuilder interface method - returning the central layers.
- Parameters
gctx – the geometry context for this build call
-
inline const std::vector<std::shared_ptr<const TGeoDetectorElement>> &detectorElements() const
Return the created detector elements.
-
inline Config getConfiguration() const
Get the configuration object.
-
inline virtual const std::string &identification() const final
Name identification.
-
virtual const LayerVector negativeLayers(const GeometryContext &gctx) const final
LayerBuilder interface method - returning the layers at negative side.
- Parameters
gctx – the geometry context for this build call
-
virtual const LayerVector positiveLayers(const GeometryContext &gctx) const final
LayerBuilder interface method - returning the layers at negative side.
- Parameters
gctx – the geometry context for this build call
-
void setConfiguration(const Config &config)
Set the configuration object.
- Parameters
config – is the configuration struct
-
void setLogger(std::unique_ptr<const Logger> newLogger)
Set logging instance.
Public Static Functions
-
struct Config
- #include <Acts/Plugins/TGeo/TGeoLayerBuilder.hpp>
nested configuration struct for steering of the layer builder
Public Members
-
bool autoSurfaceBinning = false
Automated binning & tolerances.
-
std::string configurationName = "undefined"
String based identification.
-
std::shared_ptr<const ITGeoDetectorElementSplitter> detectorElementSplitter = nullptr
Split TGeoElement if a splitter is provided.
-
ElementFactory elementFactory = defaultElementFactory
Factory for creating detector elements based on TGeoNodes.
-
std::shared_ptr<const ITGeoIdentifierProvider> identifierProvider = nullptr
Create an indentifier from TGeoNode.
-
std::array<std::vector<LayerConfig>, 3> layerConfigurations
Configuration is always | n | c | p |.
-
std::shared_ptr<const LayerCreator> layerCreator = nullptr
Layer creator.
-
std::array<double, 3> layerSplitToleranceR = {-1., -1., -1.}
Split tolerances in R.
-
std::array<double, 3> layerSplitToleranceZ = {-1., -1., -1.}
Split tolerances in Z.
-
std::shared_ptr<const ProtoLayerHelper> protoLayerHelper = nullptr
ProtoLayer helper.
-
Acts::SurfaceBinningMatcher surfaceBinMatcher
The surface binning matcher.
-
double unit = 1 * UnitConstants::cm
Unit conversion.
-
bool autoSurfaceBinning = false
-
struct LayerConfig
- #include <Acts/Plugins/TGeo/TGeoLayerBuilder.hpp>
Helper config structs for volume parsing.
Public Types
-
using RangeConfig = std::pair<BinningValue, std::pair<double, double>>
-
using SplitConfig = std::pair<BinningValue, double>
Public Functions
-
inline LayerConfig()
Public Members
-
std::vector<std::pair<int, BinningType>> binning0 = {{-1, equidistant}}
Binning setup in l0: nbins (-1 -> automated), axis binning type.
-
std::vector<std::pair<int, BinningType>> binning1 = {{-1, equidistant}}
Binning setup in l1: nbins (-1 -> automated), axis binning type.
-
std::pair<double, double> envelope = {1 * UnitConstants::mm, 1 * UnitConstants::mm}
The envelope to be built around the layer.
-
std::string localAxes = "XYZ"
The local axis definition of TGeo object to Acts::Surface.
-
std::vector<RangeConfig> parseRanges = {}
Parse ranges: parameter and ranges.
-
std::vector<std::string> sensorNames = {}
Identify the sensor(s) by name.
-
std::vector<SplitConfig> splitConfigs = {}
Layer splitting: parameter and tolerance.
-
std::string volumeName = ""
Identify the search volume by name.
-
using RangeConfig = std::pair<BinningValue, std::pair<double, double>>
-
using ElementFactory = std::function<std::shared_ptr<TGeoDetectorElement>(const Identifier&, const TGeoNode&, const TGeoMatrix &tGeoMatrix, const std::string &axes, double scalor, std::shared_ptr<const Acts::ISurfaceMaterial> material)>
-
struct TGeoParser
- #include <Acts/Plugins/TGeo/TGeoParser.hpp>
TGeoParser is a helper struct that walks recursively through a TGeometry and selects by string comparison the TGeoNodes that match the criteria.
It also buils up the global transform for the conversion into an ACTS Surface
Public Types
-
using ParseRange = std::pair<double, double>
Public Static Functions
-
static void select(State &state, const Options &options, const TGeoMatrix &gmatrix = TGeoIdentity("ID"))
The parsing module, it takes the top Volume and recursively steps down.
- Parameters
state – [out] The parseing state configuration, passed through
options – [in] The parsing options as requiremed
gmatrix – The current built-up transform to global at this depth
-
struct Options
- #include <Acts/Plugins/TGeo/TGeoParser.hpp>
Nested configuration struct.
This contains the parsing configuration
Public Members
-
std::string localAxes = "XYZ"
The local axis definition of TGeo object wrt Acts::Surface.
-
std::vector<std::pair<BinningValue, ParseRange>> parseRanges = {}
Parse restrictions, several can apply.
-
std::vector<std::string> targetNames = {}
Identify the sensor(s)/target(s) by name.
-
double unit = 1 * UnitConstants::cm
Scaling from TGeo to ROOT.
-
std::vector<std::string> volumeNames = {}
Identify the vlume by name.
-
std::string localAxes = "XYZ"
-
struct SelectedNode
- #include <Acts/Plugins/TGeo/TGeoParser.hpp>
Public Members
-
const TGeoNode *node = nullptr
-
std::unique_ptr<TGeoMatrix> transform = nullptr
-
const TGeoNode *node = nullptr
-
struct State
- #include <Acts/Plugins/TGeo/TGeoParser.hpp>
Nested state struct.
This is needed for the recursive parsing of the geometry, it collects the information during the parsing process and keeps track of the built up transform
Public Members
-
TGeoNode *node = nullptr
-
bool onBranch = false
-
std::vector<SelectedNode> selectedNodes = {}
-
TGeoVolume *volume = nullptr
-
TGeoNode *node = nullptr
-
using ParseRange = std::pair<double, double>
-
struct TGeoPrimitivesHelper
- #include <Acts/Plugins/TGeo/TGeoPrimitivesHelper.hpp>
Public Static Functions
-
static inline Transform3 makeTransform(const Eigen::Vector3d &rotationMatrixCol0, const Eigen::Vector3d &rotationMatrixCol1, const Eigen::Vector3d &rotationMatrixCol2, const Eigen::Vector3d &translation)
Helper method to create a transform from Rotation matrix vectors:
- Parameters
rotationMatrixCol0 –
rotationMatrixCol1 –
rotationMatrixCol2 – And translation
translation –
-
static bool match(const char *first, const char *second)
Private helper method : match string with wildcards.
- Parameters
first – is the one with the potential wildcard
second – is the test string
-
static bool match(const std::vector<std::string> &first, const char *second)
Private helper method : match string with wildcards Method that uses the match method with wild cards and performs it on an input list.
- Parameters
first – is the one with the potential wildcard
second – is the test string
-
static inline Transform3 makeTransform(const Eigen::Vector3d &rotationMatrixCol0, const Eigen::Vector3d &rotationMatrixCol1, const Eigen::Vector3d &rotationMatrixCol2, const Eigen::Vector3d &translation)
-
struct TGeoSurfaceConverter
- #include <Acts/Plugins/TGeo/TGeoSurfaceConverter.hpp>
Helper struct to convert TGeoShapes into Surface or Volume Bounds.
Public Static Functions
-
static std::tuple<std::shared_ptr<const CylinderBounds>, const Transform3, double> cylinderComponents(const TGeoShape &tgShape, const Double_t *rotation, const Double_t *translation, const std::string &axes, double scalor = 10.) noexcept(false)
Convert a TGeoShape into cylinder surface components.
- Parameters
tgShape – The TGeoShape
rotation – The rotation matrix as Double_t* from root
translation – The translation vector as Double_t* from root
axes – The axes definition
scalor – The unit scalor between TGeo and Acts
- Returns
tuple of DiscBounds, Trasnform, thickness
-
static std::tuple<std::shared_ptr<const DiscBounds>, const Transform3, double> discComponents(const TGeoShape &tgShape, const Double_t *rotation, const Double_t *translation, const std::string &axes, double scalor = 10.) noexcept(false)
Convert a TGeoShape into disk surface components.
- Parameters
tgShape – The TGeoShape
rotation – The rotation matrix as Double_t* from root
translation – The translation vector as Double_t* from root
axes – The axes definition
scalor – The unit scalor between TGeo and Acts
- Returns
tuple of DiscBounds, Trasnform, thickness
-
static std::tuple<std::shared_ptr<const PlanarBounds>, const Transform3, double> planeComponents(const TGeoShape &tgShape, const Double_t *rotation, const Double_t *translation, const std::string &axes, double scalor = 10.) noexcept(false)
Convert a TGeoShape into plane surface components.
- Parameters
tgShape – The TGeoShape
rotation – The rotation matrix as Double_t* from root
translation – The translation as a Double_t*
axes – The axes definition
scalor – The unit scalor between TGeo and Acts
- Returns
tuple of PlanarBounds, Trasnform, thickness
-
static inline double toRadian(double degree)
Transalte TGeo degree [0, 360) to radian.
will correct to [-pi,pi)
- Parameters
degree – The input in degree
- Returns
angle in radians
-
static std::shared_ptr<Surface> toSurface(const TGeoShape &tgShape, const TGeoMatrix &tgMatrix, const std::string &axes, double scalor = 10.) noexcept(false)
Convert a TGeoShape to a Surface.
- Parameters
tgShape – The TGeoShape
tgMatrix – The matrix representing the tranbsform
axes – The axes definition
scalor – The unit scalor between TGeo and Acts
- Returns
shared pointer to a surface
-
static std::tuple<std::shared_ptr<const CylinderBounds>, const Transform3, double> cylinderComponents(const TGeoShape &tgShape, const Double_t *rotation, const Double_t *translation, const std::string &axes, double scalor = 10.) noexcept(false)
-
template<typename input_track_t>
class TrackAtVertex - #include <Acts/Vertexing/TrackAtVertex.hpp>
Defines a track at vertex object.
- Template Parameters
input_track_t – Track object type
Public Functions
-
TrackAtVertex() = delete
Deleted default constructor.
-
inline TrackAtVertex(double chi2perTrack, const BoundTrackParameters ¶msAtVertex, const input_track_t *originalTrack)
Parameterized constructor.
- Parameters
chi2perTrack – Chi2 of track
paramsAtVertex – Fitted perigee parameter
originalTrack – Original perigee parameter
-
inline TrackAtVertex(const BoundTrackParameters ¶msAtVertex, const input_track_t *originalTrack)
Constructor with default chi2.
- Parameters
paramsAtVertex – Fitted perigee parameter
originalTrack – Original perigee parameter
Public Members
-
double chi2Track = 0
Chi2 of track.
-
BoundTrackParameters fittedParams
Fitted perigee.
-
bool isLinearized = false
Is already linearized.
-
LinearizedTrack linearizedState
The linearized state of the track at vertex.
-
double ndf = 0
Number degrees of freedom Note: Can be different from integer value since annealing can result in effective non-interger values.
-
const input_track_t *originalParams
Original input parameters.
-
double trackWeight = 0
Weight of track in fit.
-
double vertexCompatibility = 0
Value of the compatibility of the track to the actual vertex, based on the estimation of the 3d distance between the track and the vertex.
-
template<typename vfitter_t, typename track_density_t = GaussianTrackDensity<typename vfitter_t::InputTrack_t>>
class TrackDensityVertexFinder - #include <Acts/Vertexing/TrackDensityVertexFinder.hpp>
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.
Ref. (1): https://cds.cern.ch/record/2670380
- Template Parameters
vfitter_t – The vertex fitter type (needed to fulfill concept)
track_density_t – The track density type
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline TrackDensityVertexFinder(const Config &cfg) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline TrackDensityVertexFinder() Default constructor used if InputTrack_t type == BoundTrackParameters.
-
inline TrackDensityVertexFinder(const Config &cfg, const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
-
inline TrackDensityVertexFinder(const std::function<BoundTrackParameters(InputTrack_t)> &func)
Constructor for user-defined InputTrack_t type =! BoundTrackParameters with default Config object.
- Parameters
func – Function extracting BoundTrackParameters from InputTrack_t object
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &trackVector, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Function that finds single vertex candidate.
- Parameters
trackVector – Input track collection
vertexingOptions – Vertexing options
state – State for fulfilling interfaces
- Returns
Vector of vertices, filled with a single vertex (for consistent interfaces)
-
struct Config
- #include <Acts/Vertexing/TrackDensityVertexFinder.hpp>
The Config struct.
Public Members
-
track_density_t trackDensityEstimator
-
track_density_t trackDensityEstimator
-
struct State
- #include <Acts/Vertexing/TrackDensityVertexFinder.hpp>
State struct for fulfilling interface.
-
class TrackingGeometry
- #include <Acts/Geometry/TrackingGeometry.hpp>
The TrackingGeometry class is the owner of the constructed TrackingVolumes.
It enables both, a global search for an asociatedVolume (respectively, if existing, a global search of an associated Layer or the next associated Layer), such as a continous navigation by BoundarySurfaces between the confined TrackingVolumes.
Public Functions
-
TrackingGeometry(const MutableTrackingVolumePtr &highestVolume, const IMaterialDecorator *materialDecorator = nullptr, const GeometryIdentifierHook &hook = {})
Constructor.
- Parameters
highestVolume – is the world volume
materialDecorator – is a dediated decorator that can assign surface or volume based material to the TrackingVolume
hook – Identifier hook to be applied to surfaces
-
~TrackingGeometry()
Destructor.
-
const Layer *associatedLayer(const GeometryContext &gctx, const Vector3 &gp) const
Forward the associated Layer information.
- Parameters
gctx – is the context for this request (e.g. alignment)
gp – is the global position of the call
- Returns
plain pointer to assocaiated layer
-
const Surface *findSurface(GeometryIdentifier id) const
Search for a surface with the given identifier.
- Parameters
id – is the geometry identifier of the surface
- Return values
nullptr – if no such surface exists
pointer – to the found surface otherwise.
-
const TrackingVolume *findVolume(GeometryIdentifier id) const
Search for a volume with the given identifier.
- Parameters
id – is the geometry identifier of the volume
- Return values
nullptr – if no such volume exists
pointer – to the found volume otherwise.
-
const Surface *getBeamline() const
surface representing the beam pipe
Note
The ownership is not passed, e.g. do not delete the pointer
- Returns
raw pointer to surface representing the beam pipe (could be a null pointer)
-
const TrackingVolume *highestTrackingVolume() const
Access to the world volume.
- Returns
plain pointer to the world volume
-
const TrackingVolume *lowestTrackingVolume(const GeometryContext &gctx, const Vector3 &gp) const
return the lowest tracking Volume
- Parameters
gctx – The current geometry context object, e.g. alignment
gp – is the global position of the call
- Returns
plain pointer to the lowest TrackingVolume
Register the beam tube.
- Parameters
beam – is the beam line surface
-
template<typename visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const Visit all sensitive surfaces.
- Template Parameters
visitor_t – Type of the callable visitor
- Parameters
visitor – The callable. Will be called for each sensitive surface that is found
-
TrackingGeometry(const MutableTrackingVolumePtr &highestVolume, const IMaterialDecorator *materialDecorator = nullptr, const GeometryIdentifierHook &hook = {})
-
class TrackingGeometryBuilder : public Acts::ITrackingGeometryBuilder
- #include <Acts/Geometry/TrackingGeometryBuilder.hpp>
The Acts::TrackingGeometry Builder for volumes that wrap around another.
It retrieves an array of std::functions that build the TrackingGeometry sequentially in order, with the following options:
contained (e.g. a final insertion of a beam pipe of longer extend)
wrapped (e.g. an outer detector wrapping an inner one)
attached (e.g. a neighbor detector attaching to the previous one)
The returned volume of each step must be processable by the previous step
Public Functions
-
TrackingGeometryBuilder(const Config &cgbConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("TrackingGeometryBuilder", Logging::INFO))
Constructor.
- Parameters
cgbConfig – [in] is the configuration struct for this builder
logger – [in] logging instance
-
~TrackingGeometryBuilder() override = default
Destructor.
-
inline Config getConfiguration() const
Get configuration method.
- Returns
the current configuration
-
void setConfiguration(const Config &cgbConfig)
Set configuration method.
- Parameters
cgbConfig – is the new configuration struct
-
void setLogger(std::unique_ptr<const Logger> newLogger)
set logging instance
- Parameters
newLogger – the new logging instance
-
virtual std::unique_ptr<const TrackingGeometry> trackingGeometry(const GeometryContext &gctx) const final
TrackingGeometry Interface method.
- Parameters
gctx – geometry context of that building call
- Returns
a unique pointer to a TrackingGeometry
-
struct Config
- #include <Acts/Geometry/TrackingGeometryBuilder.hpp>
Nested Configuration for the CylinderVolumeBuilder.
Public Members
-
GeometryIdentifierHook geometryIdentifierHook
Optional geometry identfier hook to be used during closure.
Note
Will be copied when calling the geometry building
-
std::shared_ptr<const IMaterialDecorator> materialDecorator = nullptr
The optional material decorator for this.
- std::vector< std::function< std::shared_ptr< TrackingVolume > const GeometryContext &gctx, const TrackingVolumePtr &, const VolumeBoundsPtr &)> > trackingVolumeBuilders
The list of tracking volume builders.
-
std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr
The tracking volume helper for detector construction.
-
GeometryIdentifierHook geometryIdentifierHook
-
class TrackingVolume : public Acts::Volume
- #include <Acts/Geometry/TrackingVolume.hpp>
Full Volume description used in Tracking, it inherits from Volume to get the geometrical structure.
A TrackingVolume at navigation level can provide the (layer) material information / internal navigation with in 5 different ways:
--- a) Static confinement of Layers --- b) detached sub volumes --- b) unordered (arbitrarily oriented) layers --- d) unordered sub volumes --- e) unordered layers AND unordered subvolumes
The TrackingVolume can also be a simple container of other TrackingVolumes
In addition it is capable of holding a subarray of Layers and TrackingVolumes.
Public Functions
-
TrackingVolume() = delete
-
TrackingVolume(const TrackingVolume&) = delete
-
~TrackingVolume() override
Set the boundary surface material description.
The material is usually derived in a complicated way and loaded from a framework given source. As various volumes could potentially share the the same material description, it is provided as a shared object
- Parameters
surfaceMaterial – Material description of this volume
bsFace – Specifies which boundary surface to assign the material to
Set the volume material description.
The material is usually derived in a complicated way and loaded from a framework given source. As various volumes could potentially share the the same material description, it is provided as a shared object
- Parameters
material – Material description of this volume
-
const Layer *associatedLayer(const GeometryContext &gctx, const Vector3 &position) const
Return the associated Layer to the global position.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the associated global position
- Returns
plain pointer to layer object
-
const TrackingVolumeBoundaries &boundarySurfaces() const
Method to return the BoundarySurfaces.
-
inline unsigned int colorCode() const
Get the color code.
Returns all boundary surfaces sorted by the user.
- Template Parameters
options_t – Type of navigation options object for decomposition
sorter_t – Type of the boundary surface sorter
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position for searching
direction – The direction for searching
options – The templated navigation options
logger – A
LoggerWrapper
instance
- Returns
is the templated boundary intersection
Resolves the volume into (compatible) Layers.
This is the method for the propagator/extrapolator
- Template Parameters
options_t – Type of navigation options object for decomposition
- Parameters
gctx – The current geometry context object, e.g. alignment
position – Position for the search
direction – Direction for the search
options – The templated navigation options
- Returns
vector of compatible intersections with layers
Return surfaces in given direction from bounding volume hierarchy.
- Template Parameters
options_t – Type of navigation options object for decomposition
- Parameters
gctx – The current geometry context object, e.g. alignment
position – The position to start from
direction – The direction towards which to test
angle – The opening angle
options – The templated navigation options
- Returns
Vector of surface candidates
-
inline const LayerArray *confinedLayers() const
Return the confined static layer array - if it exists.
- Returns
the BinnedArray of static layers if exists
-
inline std::shared_ptr<const TrackingVolumeArray> confinedVolumes() const
Return the confined volumes of this container array - if it exists.
-
inline const MutableTrackingVolumeVector denseVolumes() const
Return the confined dense volumes.
-
void glueTrackingVolume(const GeometryContext &gctx, BoundarySurfaceFace bsfMine, TrackingVolume *neighbor, BoundarySurfaceFace bsfNeighbor)
Glue another tracking volume to this one.
if common face is set the glued volumes are sharing the boundary, down to the last navigation volume
- Parameters
gctx – The current geometry context object, e.g. alignment
bsfMine – is the boundary face indicater where to glue
neighbor – is the TrackingVolume to be glued
bsfNeighbor – is the boudnary surface of the neighbor
Glue another tracking volume to this one.
if common face is set the glued volumes are sharing the boundary, down to the last navigation volume
- Parameters
gctx – The current geometry context object, e.g. alignment
bsfMine – is the boundary face indicater where to glue
neighbors – are the TrackingVolumes to be glued
bsfNeighbor – are the boudnary surface of the neighbors
-
GlueVolumesDescriptor &glueVolumesDescriptor()
Register the outside glue volumes - ordering is in the TrackingVolume Frame:
negativeFaceXY
(faces YZ, ZY, radial faces)
positiveFaceXY
-
inline bool hasBoundingVolumeHierarchy() const
Return whether this TrackingVolume has a BoundingVolumeHierarchy associated.
- Returns
If it has a BVH or not.
-
const TrackingVolume *lowestTrackingVolume(const GeometryContext &gctx, const Vector3 &position, const double tol = 0.) const
Return the associated sub Volume, returns THIS if no subVolume exists.
- Parameters
gctx – The current geometry context object, e.g. alignment
position – is the global position associated with that search
tol – Search position tolerance for dense volumes
- Returns
plain pointer to associated with the position
-
inline const TrackingVolume *motherVolume() const
Return the MotherVolume - if it exists.
-
TrackingVolume &operator=(const TrackingVolume&) = delete
-
inline void registerColorCode(unsigned int icolor)
Register the color code.
- Parameters
icolor – is a color number
-
void registerGlueVolumeDescriptor(GlueVolumesDescriptor *gvd)
Register the outside glue volumes - ordering is in the TrackingVolume Frame:
negativeFaceXY
(faces YZ, ZY, radial faces)
positiveFaceXY
- Parameters
gvd – register a new GlueVolumeDescriptor
-
inline void setMotherVolume(const TrackingVolume *mvol)
Set the MotherVolume.
- Parameters
mvol – is the mother volume
Provide a new BoundarySurface from the glueing.
- Parameters
bsf – is the boundary face indicater where to glue
bs – is the new boudnary surface
checkmaterial – is a flag how to deal with material, if true:
if the old boundary surface had a material description but the new one has not, keep the current one
in all other cases just assign the new boundary surface
-
template<typename visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const Visit all sensitive surfaces.
If a context is needed for the vist, the vistitor has to provide this e.g. as a private member
- Template Parameters
visitor_t – Type of the callable visitor
- Parameters
visitor – The callable. Will be called for each sensitive surface that is found
-
inline const IVolumeMaterial *volumeMaterial() const
Return the material of the volume.
Return the material of the volume as shared pointer.
-
inline const std::string &volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
Public Static Functions
Factory constructor for a container TrackingVolume.
by definition a Vacuum volume
- Parameters
transform – is the global 3D transform to position the volume in space
volumeBounds – is the description of the volume boundaries
containedVolumes – are the static volumes that fill this volume
volumeName – is a string identifier
- Returns
shared pointer to a new TrackingVolume
Factory constructor for Tracking Volume with a bounding volume hierarchy.
- Parameters
transform – is the global 3D transform to position the volume in space
volbounds – is the description of the volume boundaries
boxStore – Vector owning the contained bounding boxes
descendants – Vector owning the child volumes
top – The top of the hierarchy (top node)
volumeMaterial – is the materials of the tracking volume
volumeName – is a string identifier
- Returns
shared pointer to a new TrackingVolume
Factory constructor for Tracking Volumes with content.
can not be a container volume
- Parameters
transform – is the global 3D transform to position the volume in space
volumeBounds – is the description of the volume boundaries
volumeMaterial – is are materials of the tracking volume
containedLayers – is the confined layer array (optional)
containedVolumes – is the confined volume array (optional)
denseVolumes – is the array of dense volulmes (optional)
volumeName – is a string identifier
- Returns
shared pointer to a new TrackingVolume
-
TrackingVolume() = delete
-
class TrackingVolumeArrayCreator : public Acts::ITrackingVolumeArrayCreator
- #include <Acts/Geometry/TrackingVolumeArrayCreator.hpp>
The TrackingVolumeArrayCreator is a simple Tool that helps to construct binned arrays of TrackingVolumes for both, confinement in another volume and navigation issues.
Public Functions
-
inline TrackingVolumeArrayCreator(const Config&, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerArrayCreator", Logging::INFO))
Constructor.
- Parameters
logger – logging instance
-
~TrackingVolumeArrayCreator() override = default
Destructor.
-
inline void setLogger(std::unique_ptr<const Logger> logger)
Set logging instance.
- Parameters
logger – is the logging instance to be set
-
virtual std::shared_ptr<const TrackingVolumeArray> trackingVolumeArray(const GeometryContext &gctx, const TrackingVolumeVector &tVolumes, BinningValue bValue) const override
create a tracking volume array
- Parameters
gctx – [in] the geometry context for this building
tVolumes – [in] is the vector of TrackingVolumes to be
bValue – [in] is the binning value
- Returns
new created volume array
-
struct Config
- #include <Acts/Geometry/TrackingVolumeArrayCreator.hpp>
This struct stores the configuration of the tracking geometry.
-
inline TrackingVolumeArrayCreator(const Config&, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerArrayCreator", Logging::INFO))
-
template<size_t M, bool ReadOnly = true>
struct TrackStateTraits - #include <Acts/EventData/MultiTrajectory.hpp>
Public Types
-
using Covariance = typename detail_lt::Types<eBoundSize, ReadOnly>::CovarianceMap
-
using IndexType = std::uint32_t
-
using Parameters = typename detail_lt::Types<eBoundSize, ReadOnly>::CoefficientsMap
-
using Projector = Eigen::Matrix<typename Covariance::Scalar, M, eBoundSize, ProjectorFlags>
-
using Covariance = typename detail_lt::Types<eBoundSize, ReadOnly>::CovarianceMap
-
class TrapezoidBounds : public Acts::PlanarBounds
- #include <Acts/Surfaces/TrapezoidBounds.hpp>
Bounds for a trapezoidal, planar Surface.
Public Types
-
enum BoundValues
Values:
-
enumerator eHalfLengthXnegY
-
enumerator eHalfLengthXposY
-
enumerator eHalfLengthY
-
enumerator eSize
-
enumerator eHalfLengthXnegY
Public Functions
-
TrapezoidBounds() = delete
-
inline TrapezoidBounds(double halfXnegY, double halfXposY, double halfY) noexcept(false)
Constructor for symmetric Trapezoid.
- Parameters
halfXnegY – minimal half length X, definition at negative Y
halfXposY – maximal half length X, definition at positive Y
halfY – half length Y - defined at x=0
-
inline TrapezoidBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor for symmetric Trapezoid - from fixed size array.
- Parameters
values – the values to be stream in
-
~TrapezoidBounds() override
-
virtual const RectangleBounds &boundingBox() const final
Bounding box parameters.
- Returns
rectangle bounds for a bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector2 &lposition, const BoundaryCheck &bcheck) const final
The orientation of the Trapezoid is according to the figure above, in words: the shorter of the two parallel sides of the trapezoid intersects with the negative \( y \) - axis of the local frame.
The cases are:
(0)
\( y \) or \( x \)bounds are 0 || 0
(1) the local position is outside
\( y \)bounds
(2) the local position is inside
\( y \) bounds, but outside maximum \( x \)bounds
(3) the local position is inside
\( y \) bounds AND inside minimum \( x \)bounds
(4) the local position is inside
\( y \) bounds AND inside maximum \( x \) bounds, so that it depends on the \( eta \) coordinate (5) the local position fails test of (4)The inside check is done using single equations of straight lines and one has to take care if a point lies on the positive \( x \) half area(I) or the negative one(II). Denoting \( |x_{min}| \) and \( | x_{max} | \) as
minHalfX
respectivelymaxHalfX
, such as \( | y_{H} | \) ashalfY
, the equations for the straing lines in (I) and (II) can be written as:(I): \( y = \kappa_{I} x + \delta_{I} \)
(II): \( y = \kappa_{II} x + \delta_{II} \)
,
where
\( \kappa_{I} = - \kappa_{II} = 2 \frac{y_{H}}{x_{max} - x_{min}} \) and \( \delta_{I} = \delta_{II} = - \frac{1}{2}\kappa_{I}(x_{max} + x_{min}) \)
- Parameters
lposition – Local position (assumed to be in right surface frame)
bcheck – boundary check directive
- Returns
boolean indicator for the success of this operation
-
virtual std::ostream &toStream(std::ostream &sl) const final
Output Method for std::ostream.
- Parameters
sl – is the ostream to be dumped into
-
virtual BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.
- Returns
of the stored values for this SurfaceBounds object
-
virtual std::vector<Vector2> vertices(unsigned int lseg = 1) const final
Return the vertices.
Note
the number of segements is ignored in this representation
- Parameters
lseg – the number of segments used to approximate and eventually curved line
- Returns
vector for vertices in 2D
-
enum BoundValues
-
class TrapezoidVolumeBounds : public Acts::VolumeBounds
- #include <Acts/Geometry/TrapezoidVolumeBounds.hpp>
Bounds for a trapezoidal shaped Volume, the orientedSurface(…) method creates a vector of 6 surfaces:
BoundarySurfaceFace [index]:
negativeFaceXY [0] : Trazpezoidal Acts::PlaneSurface, parallel to \( xy \) plane at negative \(z\)
positiveFaceXY [1] : Trazpezoidal Acts::PlaneSurface, parallel to \( xy \) plane at positive \(z\)
trapezoidFaceAlpha [2] : Rectangular Acts::PlaneSurface, attached to [0] and [1] at negative \(x\) (associated to alpha)
trapezoidFaceBeta [3] : Rectangular Acts::PlaneSurface, attached to [0] and [1] at positive \( x\) (associated to beta)
negativeFaceZX [4] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at negative \(y\)
positiveFaceZX [5] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at positive \(y\)
Public Types
-
enum BoundValues
for acces / streaming
Values:
-
enumerator eHalfLengthXnegY
halflength in x at negative y
-
enumerator eHalfLengthXposY
halflength in x at positive y
-
enumerator eHalfLengthY
halflength in y
-
enumerator eHalfLengthZ
halflength in z
-
enumerator eAlpha
opening angle alpha (in point A)
-
enumerator eBeta
opening angle beta (in point B)
-
enumerator eSize
length of the bounds vector
-
enumerator eHalfLengthXnegY
Public Functions
-
TrapezoidVolumeBounds() = delete
-
TrapezoidVolumeBounds(double minhalex, double maxhalex, double haley, double halez) noexcept(false)
Constructor - the trapezoid boundaries (symmetric trapezoid)
- Parameters
minhalex – is the half length in x at minimal y
maxhalex – is the half length in x at maximal y
haley – is the half length in y
halez – is the half length in z
-
TrapezoidVolumeBounds(double minhalex, double haley, double halez, double alpha, double beta) noexcept(false)
Constructor - the trapezoid boundaries (arbitrary trapezoid)
- Parameters
minhalex – is the half length in x at minimal y
haley – is the half length in y
halez – is the half length in z
alpha – is the openeing angle at -x,-y
beta – is the openeing angle at +x,-y
-
inline TrapezoidVolumeBounds(const std::array<double, eSize> &values) noexcept(false)
Constructor - from a fixed size array.
- Parameters
values – The bound values
-
TrapezoidVolumeBounds(const TrapezoidVolumeBounds &trabo) = default
-
~TrapezoidVolumeBounds() override = default
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
inline double get(BoundValues bValue) const
Access to the bound values.
- Parameters
bValue – the class nested enum for the array access
-
virtual bool inside(const Vector3 &pos, double tol = 0.) const override
This method checks if position in the 3D volume frame is inside the cylinder.
- Parameters
pos – is the global position to be checked
tol – is the tolerance applied
- Returns
boolean indicator if position is inside
-
TrapezoidVolumeBounds &operator=(const TrapezoidVolumeBounds &trabo) = default
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const override
Output Method for std::ostream.
-
inline virtual VolumeBounds::BoundsType type() const final
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
inline virtual std::vector<double> values() const final
Return the bound values as dynamically sized vector.
- Returns
this returns a copy of the internal values
-
class VectorMultiTrajectory : public Acts::MultiTrajectory<VectorMultiTrajectory>
- #include <Acts/EventData/VectorMultiTrajectory.hpp>
Public Functions
-
VectorMultiTrajectory() = default
-
inline VectorMultiTrajectory(const VectorMultiTrajectory &other)
-
VectorMultiTrajectory(VectorMultiTrajectory&&) = default
-
VectorMultiTrajectory &operator=(const VectorMultiTrajectory&) = default
-
VectorMultiTrajectory &operator=(VectorMultiTrajectory&&) = default
-
VectorMultiTrajectory() = default
-
template<typename input_track_t>
class Vertex - #include <Acts/Vertexing/Vertex.hpp>
Class for storing vertex objects.
- Template Parameters
input_track_t – Track object type
Public Functions
-
Vertex() = default
Default constructor.
-
Vertex(const Vector3 &position)
Construct for vertex at given 3d-position, sets covariance to zero.
- Parameters
position – Vertex position
-
Vertex(const Vector4 &position)
Construct for vertex at given 4d-position, sets covariance to zero.
- Parameters
position – Vertex position
-
Vertex(const Vector3 &position, const SymMatrix3 &covariance, const std::vector<TrackAtVertex<input_track_t>> &tracks)
Vertex constructor.
- Parameters
position – Vertex position
covariance – Position covariance matrix
tracks – Vector of tracks associated with the vertex
-
Vertex(const Vector4 &position, const SymMatrix4 &covariance, const std::vector<TrackAtVertex<input_track_t>> &tracks)
Vertex constructor.
- Parameters
position – Full vertex position
covariance – 4x4 covariance matrix
tracks – Vector of tracks associated with the vertex
-
SymMatrix3 covariance() const
- Returns
Returns position covariance
-
std::pair<double, double> fitQuality() const
- Returns
Returns pair of (chi2, numberDoF)
-
const SymMatrix4 &fullCovariance() const
- Returns
Returns 4x4 covariance
-
const Vector4 &fullPosition() const
- Returns
Returns 4-position
-
Vector3 position() const
- Returns
Returns 3-position
-
void setCovariance(const SymMatrix3 &covariance)
Sets 3x3 covariance.
- Parameters
covariance – Position covariance matrix
-
void setFitQuality(double chiSquared, double numberDoF)
- Parameters
chiSquared – Chi2 of fit
numberDoF – Number of degrees of freedom
-
void setFitQuality(std::pair<double, double> fitQuality)
- Parameters
fitQuality – pair of (chi2, numberDoF)
-
void setFullCovariance(const SymMatrix4 &covariance)
Sets 4x4 covariance.
- Parameters
covariance – The 4x4 covariance matrix
-
void setFullPosition(const Vector4 &fullPosition)
Set position and time.
- Parameters
fullPosition – Vertex position and time
-
void setPosition(const Vector3 &position, ActsScalar time = 0)
Set position and time.
- Parameters
position – Vertex position
time – The time
-
void setTime(ActsScalar time)
Sets time.
- Parameters
time – The time
-
void setTracksAtVertex(const std::vector<TrackAtVertex<input_track_t>> &tracks)
- Parameters
tracks – Vector of tracks at vertex
-
ActsScalar time() const
- Returns
Returns time
-
const std::vector<TrackAtVertex<input_track_t>> &tracks() const
- Returns
Returns vector of tracks associated with the vertex
-
template<typename input_track_t>
struct VertexInfo - #include <Acts/Vertexing/AMVFInfo.hpp>
Helper struct for storing vertex related information.
Public Functions
-
VertexInfo() = default
-
inline VertexInfo(const Acts::Vertex<input_track_t> &vtx, const Acts::Vector4 &pos)
Public Members
-
Acts::Vertex<input_track_t> constraintVertex
-
std::map<const input_track_t*, const BoundTrackParameters> ip3dParams
-
bool relinearize = true
-
std::vector<const input_track_t*> trackLinks
-
VertexInfo() = default
-
template<typename input_track_t>
struct VertexingOptions - #include <Acts/Vertexing/VertexingOptions.hpp>
Vertex Finder Options.
Public Functions
-
VertexingOptions() = delete
Default contstructor is deleted.
-
inline VertexingOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, const Vertex<input_track_t> &vconstr = Vertex<input_track_t>())
VertexingOptions with context.
- Parameters
gctx – The goemetry context for this fit
mctx – The magnetic context for this fit
vconstr – The pointing contraint to a vertex
Public Members
-
std::reference_wrapper<const GeometryContext> geoContext
Context object for the geometry.
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
Context object for the magnetic field.
-
Vertex<input_track_t> vertexConstraint
The vertex constraint for the fitting.
-
VertexingOptions() = delete
-
struct ViewConfig
- #include <Acts/Visualization/ViewConfig.hpp>
Struct to concentrate all visulation configuration in order to harmonize visualization interfaces.
Public Functions
-
inline ViewConfig(bool vis = true)
Constructor to switch visibility off.
-
inline ViewConfig(const ColorRGB &rgb)
Constructor for color settings only.
Public Members
-
ColorRGB color = {250, 0, 0}
The RGB color for this object.
-
double lineThickness = 0.15
The visual line thickness for this object.
-
unsigned int nSegments = 72
The number of segments to approximate full 2pi.
-
double offset = 0.1
Out of plane drawing parameter for objects.
-
std::string outputName = ""
Write name - non-empty string indicates writing.
-
double surfaceThickness = 0.15
The visual surface thickness for this object.
-
bool triangulate = false
Whether to triangulate or not.
-
bool visible = true
Visible flag.
-
inline ViewConfig(bool vis = true)
-
class Volume : public virtual Acts::GeometryObject
- #include <Acts/Geometry/Volume.hpp>
It inhertis of GeometryObject for TDD identification.
Base class for all volumes inside the tracking realm, it defines the interface for inherited Volume classes regarding the geometrical information.
Subclassed by Acts::AbstractVolume, Acts::TrackingVolume
Public Types
-
using BoundingBox = AxisAlignedBoundingBox<Volume, ActsScalar, 3>
Public Functions
-
Volume(const Transform3 &transform, VolumeBoundsPtr volbounds)
Explicit constructor with shared arguments.
Note
This will automatically build an oriented bounding box with an envelope value of (0.05, 0.05, 0.05)mm
- Parameters
transform – is the transform to position the volume in 3D space
volbounds – is the volume boundary definitions
-
Volume(const Volume &vol, const Transform3 &shift = Transform3::Identity())
Copy Constructor - with optional shift.
Note
This will automatically build an oriented bounding box with an envelope value of (0.05, 0.05, 0.05)mm
- Parameters
vol – is the source volume for the copy
shift – is the optional shift applied as : shift * vol.transform()
-
Volume() = delete
-
virtual ~Volume() = default
-
virtual Vector3 binningPosition(const GeometryContext &gctx, BinningValue bValue) const override
The binning position method.
as default the center is given, but may be overloaded
- Parameters
gctx – The current geometry context object, e.g. alignment
bValue – is the binning value schema
- Returns
vector 3D that can be used for the binning
-
BoundingBox boundingBox(const Vector3 &envelope = {0, 0, 0}) const
Construct bounding box for this shape.
- Parameters
envelope – Optional envelope to add / subtract from min/max
- Returns
Constructed bounding box pointing to this volume
-
inline const Vector3 ¢er() const
returns the center of the volume
-
bool inside(const Vector3 &gpos, double tol = 0.) const
Inside() method for checks.
- Parameters
gpos – is the position to be checked
tol – is the tolerance parameter
- Returns
boolean indicator if the position is inside
-
inline const Transform3 &itransform() const
Returns the inverted transform of this volume.
-
Volume &operator=(const Volume &vol)
Assignment operator.
- Parameters
vol – is the source volume to be copied
-
const BoundingBox &orientedBoundingBox() const
Construct oriented bounding box for this shape.
- Returns
Constructed oriented bounding box pointing to this volume
-
inline const Transform3 &transform() const
Return methods for geometry transform.
-
inline const VolumeBounds &volumeBounds() const
returns the volumeBounds()
-
using BoundingBox = AxisAlignedBoundingBox<Volume, ActsScalar, 3>
-
class VolumeBounds
- #include <Acts/Geometry/VolumeBounds.hpp>
Pure Absract Base Class for Volume bounds.
Acts::VolumeBounds are a set of up to six confining Surfaces that are stored in a std::vector. Each type of Acts::VolumeBounds has to implement a orientedSurfaces() and a inside() method.
The Volume, retrieving a set of Surfaces from the VolumeBounds, can turn the Surfaces into BoundarySurfaces.
Subclassed by Acts::ConeVolumeBounds, Acts::CuboidVolumeBounds, Acts::CutoutCylinderVolumeBounds, Acts::CylinderVolumeBounds, Acts::GenericCuboidVolumeBounds, Acts::TrapezoidVolumeBounds
Public Types
-
enum BoundsType
This is nested to the VolumeBounds, as also SurfaceBounds will have Bounds Type.
Values:
-
enumerator eCone
-
enumerator eCuboid
-
enumerator eCutoutCylinder
-
enumerator eCylinder
-
enumerator eGenericCuboid
-
enumerator eTrapezoid
-
enumerator eOther
-
enumerator eCone
Public Functions
-
VolumeBounds() = default
-
virtual ~VolumeBounds() = default
-
inline virtual double binningBorder(BinningValue bValue) const
Binning borders in double.
- Parameters
bValue – is the binning schema used
- Returns
float offset to be used for the binning
-
inline virtual Vector3 binningOffset(BinningValue bValue) const
Binning offset - overloaded for some R-binning types.
- Parameters
bValue – is the binning schema used
- Returns
vector 3D to be used for the binning
-
virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const = 0
Construct bounding box for this shape.
- Parameters
trf – Optional transform
envelope – Optional envelope to add / subtract from min/max
entity – Entity to associate this bounding box with
- Returns
Constructed bounding box
-
virtual bool inside(const Vector3 &gpos, double tol = 0.) const = 0
Checking if position given in volume frame is inside.
- Parameters
gpos – is the global position to be checked
tol – is the tolerance applied for the inside check
- Returns
boolean indicating if the position is inside
-
virtual OrientedSurfaces orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const = 0
Oriented surfaces, i.e.
the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface
It will throw an exception if the orientation prescription is not adequate
- Parameters
transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space
- Returns
a vector of surfaces bounding this volume
-
virtual std::ostream &toStream(std::ostream &sl) const = 0
Output Method for std::ostream, to be overloaded by child classes.
- Parameters
sl – is the output stream to be dumped into
-
virtual BoundsType type() const = 0
Return the bounds type - for persistency optimization.
- Returns
is a BoundsType enum
-
virtual std::vector<double> values() const = 0
Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.
- Returns
of the stored values for this SurfaceBounds object
-
enum BoundsType
-
template<typename Selector = VolumeSelector>
struct VolumeCollector - #include <Acts/Propagator/VolumeCollector.hpp>
A Volume Collector struct templated with a Selector type.
Whenever a volume is passed in the propagation that satisfies the selector, it is recorded for further usage in the flow.
Public Types
-
using result_type = this_result
Public Functions
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t &state, const stepper_t &stepper, result_type &result) const Collector action for the ActionList of the Propagator It checks if the propagator state has a current volume, in which case the action is performed:
it records the volume given the configuration
- Template Parameters
propagator_state_t – is the type of Propagator state
stepper_t – Type of the stepper used for the propagation
- Parameters
state – [inout] is the mutable stepper state object
stepper – [in] The stepper in use
result – [inout] is the mutable result object
-
template<typename propagator_state_t, typename stepper_t>
inline void operator()(propagator_state_t&, const stepper_t&) const Pure observer interface.
this does not apply to the volume collector
Public Members
-
Selector selector
The selector used for this volume.
-
struct this_result
- #include <Acts/Propagator/VolumeCollector.hpp>
Simple result struct to be returned It has all the VolumeHit objects that are collected (and thus have been selected)
Public Members
-
std::vector<VolumeHit> collected
-
std::vector<VolumeHit> collected
-
using result_type = this_result
-
struct VolumeConfig
- #include <Acts/Geometry/CylinderVolumeBuilder.hpp>
VolumeConfig struct to understand the layer config.
Public Functions
-
inline VolumeConfig()
Default constructor.
-
inline void adapt(const VolumeConfig &lConfig)
Adapt to the dimensions of another config it will take the maximum/minimum values and just overwrite them.
- Parameters
lConfig – [in] is the config to which it should be adapded
-
inline void adaptR(const VolumeConfig &lConfig)
Adapt to the dimensions of another config in R it will take the maximum/minimum values and just overwrite them.
- Parameters
lConfig – [in] is the config to which it should be adapded
-
inline void adaptZ(const VolumeConfig &lConfig)
Adapt to the dimensions of another config in Z it will take the maximum/minimum values and just overwrite them.
- Parameters
lConfig – [in] is the config to which it should be adapded
-
inline void attachZ(const VolumeConfig &lConfig)
Attach method - const it attaches the one volume config to the other one.
- Parameters
lConfig – [in] is the confit to which it should be attached
-
inline bool contains(const VolumeConfig &vConfig) const
Check if contained full set.
- Parameters
vConfig – [in] is the config against which is checked
-
inline bool containsInR(const VolumeConfig &vConfig) const
Check if contained radially.
- Parameters
vConfig – [in] is the config against which is checked
-
inline bool containsInZ(const VolumeConfig &vConfig) const
Check if contained longitudinally.
- Parameters
vConfig – [in] is the config against which is checked
-
inline void midPointAttachZ(VolumeConfig &lConfig)
Attach method - non-const it attaches the one volume config to the other one in Z this is the non-cost method, i.e.
the mid point is used
Note
lConfig will be changed
- Parameters
lConfig – [in] is the config to which it should be attached
-
inline operator bool() const
Conversion operator to bool.
-
inline bool overlapsInR(const VolumeConfig &vConfig) const
Overlap check radially.
- Parameters
vConfig – [in] is the config against which is checked
- Returns
boolean if the overlap in r exists
-
inline bool overlapsInZ(const VolumeConfig &vConfig) const
Overlap check longitudinally.
- Parameters
vConfig – [in] is the config against which is checked
- Returns
boolean if the overlap in z exists
-
inline std::string toString() const
Method for output formatting.
-
inline bool wraps(const VolumeConfig &vConfig) const
Compatibility check full set.
- Parameters
vConfig – [in] is the config against which is checked
- Returns
boolean if the current volume wraps the vConfig fully
Public Members
-
LayerVector layers
the layers you have
-
bool present = {false}
layers are present
-
double rMax
max parameter r
-
double rMin
min parameter r
-
MutableTrackingVolumeVector volumes
the confined volumes you have
-
bool wrapping = {false}
in what way they are binned
-
double zMax
max parameter z
-
double zMin
min parameter z
-
inline VolumeConfig()
-
struct VolumeHit
- #include <Acts/Propagator/VolumeCollector.hpp>
The information to be writtern out per hit volume.
-
class VolumeMaterialMapper
- #include <Acts/Material/VolumeMaterialMapper.hpp>
VolumeMaterialMapper.
This is the main feature tool to map material information from a 3D geometry onto the TrackingGeometry with its surface material description.
The process runs as such:
1) TrackingGeometry is parsed and for each Volume with ProtoVolumeMaterial a local store is initialized the identification is done hereby through the Volume::GeometryIdentifier
2) A number of N material tracks is read in, each track has : origin, direction, material steps (< position, step length, x0, l0, a, z, rho >, thichness)
for each track: volume along the origin/direction path are collected. the step are then associated to volume inside which they are. Additional step are created along the track direction.
3) Each ‘hit’ bin per event is counted and averaged at the end of the run
Public Types
-
using StraightLinePropagator = Propagator<StraightLineStepper, Navigator>
Public Functions
-
VolumeMaterialMapper() = delete
Delete the Default constructor.
-
VolumeMaterialMapper(const Config &cfg, StraightLinePropagator propagator, std::unique_ptr<const Logger> slogger = getDefaultLogger("VolumeMaterialMapper", Logging::INFO))
Constructor with config object.
- Parameters
cfg – Configuration struct
propagator – The straight line propagator
slogger – The logger
-
State createState(const GeometryContext &gctx, const MagneticFieldContext &mctx, const TrackingGeometry &tGeometry) const
helper method that creates the cache for the mapping
This method takes a TrackingGeometry, finds all surfaces with material proxis and returns you a Cache object tO be used
- Parameters
gctx – [in] The geometry context to use
mctx – [in] The magnetic field context to use
tGeometry – [in] The geometry which should be mapped
-
void finalizeMaps(State &mState) const
Method to finalize the maps.
It calls the final run averaging and then transforms the Homogeneous material into HomogeneousVolumeMaterial and the 2D and 3D grid into a InterpolatedMaterialMap
- Parameters
mState –
-
void mapMaterialTrack(State &mState, RecordedMaterialTrack &mTrack) const
Process/map a single track.
Note
the RecordedMaterialSlab of the track are assumed to be ordered from the starting position along the starting direction
- Parameters
mState – The current state map
mTrack – The material track to be mapped
-
struct Config
- #include <Acts/Material/VolumeMaterialMapper.hpp>
Nested Configuration struct for the material mapper.
Public Members
-
float mappingStep = 1.
Size of the step for the step extrapolation.
-
float mappingStep = 1.
-
struct State
- #include <Acts/Material/VolumeMaterialMapper.hpp>
Nested State struct which is used for the mapping prococess.
Public Functions
-
inline State(const GeometryContext &gctx, const MagneticFieldContext &mctx)
Constructor of the Sate with contexts.
Public Members
-
std::reference_wrapper<const GeometryContext> geoContext
Reference to the geometry context for the mapping.
-
std::map<const GeometryIdentifier, Grid2D> grid2D
The 2D material grid for each geometry ID.
-
std::map<const GeometryIdentifier, Grid3D> grid3D
The 3D material grid for each geometry ID.
-
std::map<const GeometryIdentifier, Acts::AccumulatedVolumeMaterial> homogeneousGrid
The recorded material per geometry ID.
-
std::reference_wrapper<const MagneticFieldContext> magFieldContext
Reference to the magnetic field context.
-
std::map<const GeometryIdentifier, BinUtility> materialBin
The binning for each geometry ID.
-
std::map<GeometryIdentifier, std::shared_ptr<const ISurfaceMaterial>> surfaceMaterial
The surface material of the input tracking geometry.
-
std::map<const GeometryIdentifier, std::function<Acts::Vector2(Acts::Vector3)>> transform2D
The recorded 2D transform associated the grid for each geometry ID.
-
std::map<const GeometryIdentifier, std::function<Acts::Vector3(Acts::Vector3)>> transform3D
The recorded 3D transform associated the material grid for each geometry ID.
-
std::map<GeometryIdentifier, std::unique_ptr<const IVolumeMaterial>> volumeMaterial
The created volume material from it.
-
inline State(const GeometryContext &gctx, const MagneticFieldContext &mctx)
-
using StraightLinePropagator = Propagator<StraightLineStepper, Navigator>
-
struct VolumeSelector
- #include <Acts/Propagator/VolumeCollector.hpp>
Simple struct to select volumes.
Public Functions
-
inline VolumeSelector(bool sMaterial = true, bool sLayer = false, bool sPassive = false)
VolumeSelector with options.
- Parameters
sMaterial – is the directive to select material volumes
sLayer – is the directive to select volumes with layers
sPassive – is the directive to select passive volumes
-
inline bool operator()(const Acts::TrackingVolume &volume) const
Call operator to check if a volume should be selected.
- Parameters
volume – is the test volume
Public Members
-
bool selectLayer = false
-
bool selectMaterial = true
-
bool selectPassive = false
-
inline VolumeSelector(bool sMaterial = true, bool sLayer = false, bool sPassive = false)
-
struct WeightedComponentReducerLoop
- #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
Reducer struct for the Loop MultiEigenStepper which reduces the multicomponent state to simply by summing the weighted values.
Public Static Functions
-
template<typename stepper_state_t>
static inline ActsScalar charge(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline FreeVector cov(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline Vector3 direction(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline ActsScalar momentum(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline FreeVector pars(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline Vector3 position(const stepper_state_t &s)
-
template<typename stepper_state_t>
static inline ActsScalar time(const stepper_state_t &s)
-
template<typename component_range_t>
static inline Vector3 toVector3(const component_range_t &comps, const FreeIndices i)
-
template<typename stepper_state_t>
-
struct WrappingConfig
- #include <Acts/Geometry/CylinderVolumeBuilder.hpp>
The WrappingSetup that is happening here.
Public Functions
-
WrappingConfig() = default
constructor
-
inline void configureContainerVolume()
configure the new Volume
-
inline std::string toString() const
Method for output formatting.
-
inline void wrapInsertAttach()
wrap, insert, attach
Public Members
-
VolumeConfig containerVolumeConfig
the combined volume
-
VolumeConfig cVolumeConfig
-
VolumeConfig existingVolumeConfig
existing volume config with potential gaps
-
VolumeConfig externalVolumeConfig
externally provided config, this can only change the the ncp volumes
-
VolumeConfig fGapVolumeConfig
-
VolumeConfig nVolumeConfig
the new volumes
-
VolumeConfig pVolumeConfig
-
VolumeConfig sGapVolumeConfig
-
WrappingCondition wCondition = Undefined
-
std::string wConditionScreen = "[left untouched]"
-
WrappingConfig() = default
-
template<typename vfitter_t>
class ZScanVertexFinder - #include <Acts/Vertexing/ZScanVertexFinder.hpp>
Implements a vertex finder based on the mode of z0 values:
Determines the mode value of all input track z0 values
If no contraint is given, returns (0,0, z0_mode) as vertex position
If vertex contraint is given with x=x_constr and y=y_constr, the returned vertex position will be (x_constr, y_constr, z0_mode).
Public Types
-
using InputTrack_t = typename vfitter_t::InputTrack_t
Public Functions
-
template<typename T = InputTrack_t, std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
inline ZScanVertexFinder(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("ZScanVertexFinder", Logging::INFO)) Constructor used if InputTrack_t type == BoundTrackParameters.
- Parameters
cfg – Configuration object
logger – The logging instance
-
inline ZScanVertexFinder(const Config &cfg, std::function<BoundTrackParameters(InputTrack_t)> func, std::unique_ptr<const Logger> logger = getDefaultLogger("ZScanVertexFinder", Logging::INFO))
Constructor for user-defined InputTrack_t type =! BoundTrackParameters.
- Parameters
cfg – Configuration object
func – Function extracting BoundTrackParameters from InputTrack_t object
logger – Logging instance
-
Result<std::vector<Vertex<InputTrack_t>>> find(const std::vector<const InputTrack_t*> &trackVector, const VertexingOptions<InputTrack_t> &vertexingOptions, State &state) const
Function that determines single vertex, based on z0 values of input tracks, using a Half Sample Mode algorithm.
- Parameters
trackVector – Input track collection
vertexingOptions – Vertexing options
state – State for fulfilling correct interface
- Returns
Vector of vertices, filled with a single vertex (for consistent interfaces)
-
struct Config
- #include <Acts/Vertexing/ZScanVertexFinder.hpp>
Configuration struct.
Public Functions
-
inline Config(const ImpactPointEstimator<InputTrack_t, Propagator_t> &ipEst)
Finder configuration.
- Parameters
ipEst – ImpactPointEstimator
Public Members
-
float constraintcutoff = 9.
-
float constrainttemp = 1.
-
bool disableAllWeights = false
-
double expPt = 1.
-
ImpactPointEstimator<InputTrack_t, Propagator_t> ipEstimator
-
double minPt = 0.4 * UnitConstants::GeV
-
double minWeight = 0.01
-
FsmwMode1dFinder mode1dFinder
-
bool useLogPt = true
-
bool usePt = false
-
inline Config(const ImpactPointEstimator<InputTrack_t, Propagator_t> &ipEst)
-
struct State
- #include <Acts/Vertexing/ZScanVertexFinder.hpp>
State struct for fulfilling interface.
-
namespace Ccl
Typedefs
-
using Label = int
Enums
-
enum ConnectResult
Values:
-
enumerator eNoConn
-
enumerator eNoConnStop
-
enumerator eConn
-
enumerator eNoConn
Functions
-
template<typename CellCollection, typename ClusterCollection, typename Connect = DefaultConnect<typename CellCollection::value_type>>
ClusterCollection createClusters(CellCollection &cells, Connect connect = Connect()) createClusters Conveniance function which runs both labelClusters and createClusters.
-
template<typename CellCollection, typename Connect = DefaultConnect<typename CellCollection::value_type>>
void labelClusters(CellCollection &cells, Connect connect = Connect()) labelClusters
In-place connected component labelling using the Hoshen-Kopelman algorithm. The
Cell
type must have the following functions defined: int getCellRow(const Cell&), int getCellColumn(const Cell&) int& getCellLabel(Cell&)- Parameters
cells – [in] the cell collection to be labeled
connect – [in] the connection type (see DefaultConnect)
-
template<typename CellCollection, typename ClusterCollection>
ClusterCollection mergeClusters(CellCollection &cells) mergeClusters
Merge a set of cells previously labeled (for instance with
labelClusters
) into actual clusters. The Cluster type must have the following function defined: void clusterAddCell(Cluster&, const Cell&)- Parameters
cells – [in] the labeled cell collection
- Returns
nothing
Variables
-
constexpr Label NO_LABEL = 0
-
template<typename Cell>
struct DefaultConnect - #include <Acts/Clusterization/Clusterization.hpp>
Public Functions
-
inline DefaultConnect()
-
inline DefaultConnect(bool commonCorner)
-
ConnectResult operator()(const Cell &ref, const Cell &iter)
Public Members
-
bool conn8
-
inline DefaultConnect()
-
using Label = int
-
namespace Concepts
Typedefs
-
using detected_or = detail::detector<Default, void, Op, Args...>
Helper which invokes the detector with a default type, and resolves to the type.
- Template Parameters
Default – The type to resolve to if
Op<Args...>
does not resolve.Op – The operation
Args – The argument to the operation
-
using detected_t = typename detail::detector<detail::nonesuch, void, Op, Args...>::type
This type calls into the detector (same as
is_detected
) but it extracts the return type ofOp<Args...>
.- Template Parameters
Op – The operation
Args – The arguments to the operation
-
using is_detected = typename detail::detector<detail::nonesuch, void, Op, Args...>::value_t
This type ties together the detection idiom.
It instantiates the
detector
template with theOp
andArgs
and resolves to the exact value type. In essence, ifOp<Args...>
succeeds, this will evaluate tostd::true_type
, and if not, it will evaluate tostd::false_type
.- Template Parameters
Op – The operation to test
Args – The arguments to the operation
-
using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>
This evaluates
Op
inside the detector, and checks whether the resolved type is convertible toTo
.- Template Parameters
To – The type to check convertibility to.
Op – The operation
Args – The arguments to the operation
-
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>
This invokes
detected_t
, and checks whether its result matchesExpected
.- Template Parameters
Expected – The expected result of the operation.
Op – The operation
Args – The arguments to the operation
-
using ReturnTypeAbsoluteMomentum = decltype(std::declval<T>().absoluteMomentum())
-
using ReturnTypeCharge = decltype(std::declval<T>().charge())
-
using ReturnTypeCovariance = decltype(std::declval<T>().covariance())
-
using ReturnTypeFourPosition = decltype(std::declval<T>().fourPosition())
-
using ReturnTypeFourPositionFromContext = decltype(std::declval<T>().fourPosition(std::declval<GeometryContext>()))
-
using ReturnTypeParameters = decltype(std::declval<T>().parameters())
-
using ReturnTypePosition = decltype(std::declval<T>().position())
-
using ReturnTypePositionFromContext = decltype(std::declval<T>().position(std::declval<GeometryContext>()))
-
using ReturnTypeReferenceSurface = decltype(std::declval<T>().referenceSurface())
-
using ReturnTypeTime = decltype(std::declval<T>().time())
-
using ReturnTypeUnitDirection = decltype(std::declval<T>().unitDirection())
-
using TypeCovarianceMatrix = typename T::CovarianceMatrix
-
using TypeParametersVector = typename T::ParametersVector
-
using TypeScalar = typename T::Scalar
Variables
-
template<typename parameters_t>
constexpr bool BoundTrackParametersConcept = BoundTrackParametersConceptImpl<parameters_t>::value
-
template<class To, template<class...> class Op, class ...Args>
constexpr bool converts_to = is_detected_convertible<To, Op, Args...>::value Alias to conversion check, which also extracts the constexpr boolean value.
- Template Parameters
To – The type to check convertibility to.
Op – The operation
Args – The arguments to the operation.
-
template<bool... Bs>
constexpr bool disallow = not require<Bs...> Alias for the negation of a
require
.This is essentially a NOT ANY test.
- Template Parameters
Bs – The booleans.
-
template<bool... Bs>
constexpr bool either = std::disjunction<std::bool_constant<Bs>...>::value Helper which forms the logical OR of its arguments.
Converts to
std::bool_constant
.- Template Parameters
Bs – The booleans to combine.
-
template<template<class...> class Op, class ...Args>
constexpr bool exists = is_detected<Op, Args...>::value Alias to
is_detected
which unpacks the constexpr boolean value.- Template Parameters
Op – The operation
Args – The arguments to the operation.
-
template<typename parameters_t>
constexpr bool FreeTrackParametersConcept = FreeTrackParametersConceptImpl<parameters_t>::value
-
template<typename T, template<class...> class M, typename V>
constexpr bool has_member = identical_to<V, M, T> Helper to assert if a member of a given type exists.
Basically only calls into
identical_to
but is nicer to read.- Template Parameters
T – The type to check existence of member on.
M – The member type trait
V – The type that the member is supposed to have.
-
template<typename T, typename R, template<class...> class M, typename ...Arguments>
constexpr bool has_method = M<T, R, Arguments...>::template tv<T>::value Helper which evaluates whether the type
T
has a method with a given signature.- Template Parameters
T – The type to check on. This can contain a const qualifier if you want to check on that.
R – The return type
M – The method trait, as generated by METHOD_TRAIT
Arguments – The argument types that make up the signature.
-
template<class Exact, template<class...> class Op, class ...Args>
constexpr bool identical_to = is_detected_exact<Exact, Op, Args...>::value Unpacks the constexpr boolean value from
is_detected_exact
- Template Parameters
Exact – The type to check identity against
Op – The operation
Args – The arguments to the operation.
-
template<bool... Bs>
constexpr bool require = std::conjunction<std::bool_constant<Bs>...>::value Define some sort of “Domain Specific Language” to declare concepts a little more naturally.
These are taken from https://izzys.casa/2016/09/implementing-concepts-in-cxx/ Helper which combines a set of predicates (constexpr bools) with a logical AND. Converts to
std::bool_constant
.- Template Parameters
Bs – The booleans to combine
-
template<typename T>
struct BoundTrackParametersConceptImpl - #include <Acts/EventData/TrackParametersConcept.hpp>
Public Static Attributes
-
static constexpr bool hasMethodAbsoluteMomentum = identical_to<TypeScalar<T>, ReturnTypeAbsoluteMomentum, const T>
-
static constexpr bool hasMethodCharge = identical_to<TypeScalar<T>, ReturnTypeCharge, const T>
-
static constexpr bool hasMethodCovariance = std::is_convertible_v<ReturnTypeCovariance<T>, std::optional<BoundSymMatrix>>
-
static constexpr bool hasMethodFourPositionFromContext = identical_to<Vector4, ReturnTypeFourPositionFromContext, const T>
-
static constexpr bool hasMethodParameters = std::is_convertible_v<ReturnTypeParameters<T>, BoundVector>
-
static constexpr bool hasMethodPositionFromContext = identical_to<Vector3, ReturnTypePositionFromContext, const T>
-
static constexpr bool hasMethodReferenceSurface = identical_to<const Surface&, ReturnTypeReferenceSurface, const T>
-
static constexpr bool hasMethodTime = identical_to<TypeScalar<T>, ReturnTypeTime, const T>
-
static constexpr bool hasMethodUnitDirection = identical_to<Vector3, ReturnTypeUnitDirection, const T>
-
static constexpr bool hasTypeCovarianceMatrix = exists<TypeCovarianceMatrix, const T>
-
static constexpr bool hasTypeParametersVector = exists<TypeParametersVector, const T>
-
static constexpr bool hasTypeScalar = exists<TypeScalar, const T>
-
static constexpr bool value = require<hasTypeScalar, hasTypeParametersVector, hasTypeCovarianceMatrix, hasMethodParameters, hasMethodCovariance, hasMethodFourPositionFromContext, hasMethodPositionFromContext, hasMethodTime, hasMethodUnitDirection, hasMethodAbsoluteMomentum, hasMethodCharge, hasMethodReferenceSurface>
-
static constexpr bool hasMethodAbsoluteMomentum = identical_to<TypeScalar<T>, ReturnTypeAbsoluteMomentum, const T>
-
template<typename T>
struct FreeTrackParametersConceptImpl - #include <Acts/EventData/TrackParametersConcept.hpp>
Public Static Attributes
-
static constexpr bool hasMethodAbsoluteMomentum = identical_to<TypeScalar<T>, ReturnTypeAbsoluteMomentum, const T>
-
static constexpr bool hasMethodCharge = identical_to<TypeScalar<T>, ReturnTypeCharge, const T>
-
static constexpr bool hasMethodCovariance = std::is_convertible_v<ReturnTypeCovariance<T>, std::optional<FreeSymMatrix>>
-
static constexpr bool hasMethodFourPosition = identical_to<Vector4, ReturnTypeFourPosition, const T>
-
static constexpr bool hasMethodParameters = std::is_convertible_v<ReturnTypeParameters<T>, FreeVector>
-
static constexpr bool hasMethodPosition = identical_to<Vector3, ReturnTypePosition, const T>
-
static constexpr bool hasMethodTime = identical_to<TypeScalar<T>, ReturnTypeTime, const T>
-
static constexpr bool hasMethodUnitDirection = identical_to<Vector3, ReturnTypeUnitDirection, const T>
-
static constexpr bool hasTypeCovarianceMatrix = exists<TypeCovarianceMatrix, const T>
-
static constexpr bool hasTypeParametersVector = exists<TypeParametersVector, const T>
-
static constexpr bool hasTypeScalar = exists<TypeScalar, const T>
-
static constexpr bool hasMethodAbsoluteMomentum = identical_to<TypeScalar<T>, ReturnTypeAbsoluteMomentum, const T>
-
namespace Linearizer
Typedefs
-
using propagator_t = typename T::Propagator_t
-
using state_t = typename T::State
Functions
-
METHOD_TRAIT(linTrack_t, linearizeTrack)
-
template<typename S>
struct LinearizerConcept - #include <Acts/Vertexing/LinearizerConcept.hpp>
Public Static Attributes
-
static constexpr bool linTrack_exists = has_method<const S, Result<LinearizedTrack>, linTrack_t, constBoundTrackParameters&, constVector4&, constActs::GeometryContext&, constActs::MagneticFieldContext&, typename S::State&>
-
static constexpr bool propagator_exists = exists<propagator_t, S>
-
static constexpr bool value = require<linTrack_exists, propagator_exists, state_exists>
-
static constexpr bool linTrack_exists = has_method<const S, Result<LinearizedTrack>, linTrack_t, constBoundTrackParameters&, constVector4&, constActs::GeometryContext&, constActs::MagneticFieldContext&, typename S::State&>
-
using propagator_t = typename T::Propagator_t
-
namespace SourceLinkAccessor
Typedefs
-
using container_t = typename T::Container
-
using iterator_t = typename T::Iterator
-
using key_t = typename T::Key
-
using value_t = typename T::Value
Functions
-
METHOD_TRAIT(count_t, count)
-
METHOD_TRAIT(range_t, range)
-
METHOD_TRAIT(at_t, at)
-
template<typename S>
struct SourceLinkAccessorConcept - #include <Acts/TrackFinding/SourceLinkAccessorConcept.hpp>
Public Static Attributes
-
static constexpr bool at_exists = has_method<const S, const typename S::Value&, at_t, const typename S::Iterator&>
-
static constexpr bool container_exists = exists<container_t, S>
-
static constexpr bool container_pointer_exists = std::is_same_v<std::decay_t<decltype(*(std::declval<S>().container))>, container_t<S>>
-
static constexpr bool count_exists = has_method<const S, size_t, count_t, constSurface&>
-
static constexpr bool iterator_exists = exists<iterator_t, S>
-
static constexpr bool range_exists = has_method<const S, std::pair<typename S::Iterator, typename S::Iterator>, range_t, constSurface&>
-
static constexpr bool value = require<container_exists, key_exists, value_exists, container_pointer_exists, iterator_exists, count_exists, range_exists, at_exists>
-
static constexpr bool at_exists = has_method<const S, const typename S::Value&, at_t, const typename S::Iterator&>
-
using container_t = typename T::Container
-
namespace Stepper
Typedefs
-
using bound_state_t = typename T::BoundState
-
using cov_t = decltype(std::declval<T>().cov)
-
using cov_transport_t = decltype(std::declval<T>().covTransport)
-
using covariance_t = typename T::Covariance
-
using curvilinear_state_t = typename T::CurvilinearState
-
using jacobian_t = typename T::Jacobian
-
using path_accumulated_t = decltype(std::declval<T>().pathAccumulated)
-
using state_t = typename T::State
-
using step_size_t = decltype(std::declval<T>().stepSize)
Functions
-
METHOD_TRAIT(reset_state_t, resetState)
-
METHOD_TRAIT(get_field_t, getField)
-
METHOD_TRAIT(position_t, position)
-
METHOD_TRAIT(direction_t, direction)
-
METHOD_TRAIT(momentum_t, momentum)
-
METHOD_TRAIT(charge_t, charge)
-
METHOD_TRAIT(time_t, time)
-
METHOD_TRAIT(overstep_t, overstepLimit)
-
METHOD_TRAIT(bound_state_method_t, boundState)
-
METHOD_TRAIT(curvilinear_state_method_t, curvilinearState)
-
METHOD_TRAIT(update_t, update)
-
METHOD_TRAIT(covariance_transport_bound_t, transportCovarianceToBound)
-
METHOD_TRAIT(covariance_transport_curvilinear_t, transportCovarianceToCurvilinear)
-
METHOD_TRAIT(step_t, step)
-
METHOD_TRAIT(update_surface_status_t, updateSurfaceStatus)
-
METHOD_TRAIT(set_step_size_t, setStepSize)
-
METHOD_TRAIT(get_step_size_t, getStepSize)
-
METHOD_TRAIT(release_step_size_t, releaseStepSize)
-
METHOD_TRAIT(output_step_size_t, outputStepSize)
Variables
-
template<typename S>
constexpr bool MultiStepperStateConcept = require<has_member<S, cov_transport_t, bool>, has_member<S, nav_dir_t, NavigationDirection>, has_member<S, path_accumulated_t, double>>
-
template<typename S>
constexpr bool StepperStateConcept = require<has_member<S, cov_transport_t, bool>, has_member<S, cov_t, BoundSymMatrix>, has_member<S, nav_dir_t, NavigationDirection>, has_member<S, path_accumulated_t, double>>
-
template<typename S, typename state = typename S::State>
struct CommonStepperConcept - #include <Acts/Propagator/StepperConcept.hpp>
Public Static Attributes
-
static constexpr bool bound_state_exists = exists<bound_state_t, S>
-
static constexpr bool bound_state_method_exists = has_method<const S, Result<typename S::BoundState>, bound_state_method_t, state&, const Surface&, bool, const FreeToBoundCorrection&>
-
static constexpr bool charge_exists = has_method<const S, double, charge_t, const state&>
-
static constexpr bool covariance_exists = exists<covariance_t, S>
-
static constexpr bool covariance_transport_exists = require<has_method<const S, void, covariance_transport_curvilinear_t, state&>, has_method<const S, void, covariance_transport_bound_t, state&, const Surface&, const FreeToBoundCorrection&>>
-
static constexpr bool curvilinear_state_exists = exists<curvilinear_state_t, S>
-
static constexpr bool curvilinear_state_method_exists = has_method<const S, typename S::CurvilinearState, curvilinear_state_method_t, state&, bool>
-
static constexpr bool direction_exists = has_method<const S, Vector3, direction_t, const state&>
-
static constexpr bool get_step_size_exists = has_method<const S, double, get_step_size_t, const state&, ConstrainedStep::Type>
-
static constexpr bool jacobian_exists = exists<jacobian_t, S>
-
static constexpr bool momentum_exists = has_method<const S, double, momentum_t, const state&>
-
static constexpr bool output_step_size_exists = has_method<const S, std::string, output_step_size_t, const state&>
-
static constexpr bool overstep_exists = has_method<const S, double, overstep_t, const state&>
-
static constexpr bool position_exists = has_method<const S, Vector3, position_t, const state&>
-
static constexpr bool release_step_size_exists = has_method<const S, void, release_step_size_t, state&>
-
static constexpr bool reset_state_exists = has_method<const S, void, reset_state_t, state&, const BoundVector&, const BoundSymMatrix&, const Surface&, const NavigationDirection, const double>
-
static constexpr bool set_step_size_exists = has_method<const S, void, set_step_size_t, state&, double, ConstrainedStep::Type, bool>
-
static constexpr bool time_exists = has_method<const S, double, time_t, const state&>
-
static constexpr bool update_surface_exists = has_method<const S, Intersection3D::Status, update_surface_status_t, state&, const Surface&, const BoundaryCheck&, LoggerWrapper>
-
static constexpr bool value = require<state_exists, jacobian_exists, covariance_exists, bound_state_exists, curvilinear_state_exists, position_exists, direction_exists, momentum_exists, charge_exists, time_exists, bound_state_method_exists, curvilinear_state_method_exists, covariance_transport_exists, update_surface_exists, set_step_size_exists, release_step_size_exists, output_step_size_exists>
-
static constexpr bool bound_state_exists = exists<bound_state_t, S>
-
template<typename S, typename state = typename S::State>
struct MultiStepperConcept - #include <Acts/Propagator/StepperConcept.hpp>
Public Types
-
using component_proxy_t = typename T::ComponentProxy
-
using const_component_proxy_t = typename T::ConstComponentProxy
Public Functions
-
METHOD_TRAIT(number_components_t, numberComponents)
-
METHOD_TRAIT(clear_components_t, clearComponents)
-
METHOD_TRAIT(remove_missed_components_t, removeMissedComponents)
Public Static Attributes
-
static constexpr bool clear_components_exists = has_method<const S, void, clear_components_t, state&>
-
static constexpr bool common_stepper_concept_fullfilled = CommonStepperConcept<S, state>::value
-
static constexpr bool component_proxy_exists = exists<component_proxy_t, S>
-
static constexpr bool const_component_proxy_exists = exists<const_component_proxy_t, S>
-
static constexpr bool number_components_exists = has_method<const S, std::size_t, number_components_t, const state&>
-
static constexpr bool remove_missed_components_exists = has_method<const S, void, remove_missed_components_t, state&>
-
static constexpr bool value = require<common_stepper_concept_fullfilled, component_proxy_exists, const_component_proxy_exists, number_components_exists, clear_components_exists, remove_missed_components_exists>
-
using component_proxy_t = typename T::ComponentProxy
-
template<typename S, typename state = typename S::State>
struct SingleStepperConcept - #include <Acts/Propagator/StepperConcept.hpp>
Public Static Attributes
-
static constexpr bool common_stepper_concept_fullfilled = CommonStepperConcept<S, state>::value
-
static constexpr bool get_field_exists = has_method<const S, Result<Vector3>, get_field_t, state&, const Vector3&>
-
static constexpr bool update_method_exists = require<has_method<const S, void, update_t, state&, const FreeVector&, const BoundVector&, const BoundSymMatrix&, const Surface&>, has_method<const S, void, update_t, state&, const Vector3&, const Vector3&, double, double>>
-
static constexpr bool value = require<common_stepper_concept_fullfilled, update_method_exists, get_field_exists>
-
static constexpr bool common_stepper_concept_fullfilled = CommonStepperConcept<S, state>::value
-
using bound_state_t = typename T::BoundState
-
namespace VertexFinder
Typedefs
-
using state_t = typename T::State
Functions
-
METHOD_TRAIT(find_t, find)
-
template<typename S>
struct VertexFinderConcept - #include <Acts/Vertexing/VertexFinderConcept.hpp>
Public Static Attributes
-
static constexpr bool find_exists = has_method<const S, Result<std::vector<Vertex<typename S::InputTrack_t>>>, find_t, const std::vector<const typename S::InputTrack_t*>&, constVertexingOptions<typename S::InputTrack_t>&, typename S::State&>
-
static constexpr bool value = require<state_exists, find_exists>
-
static constexpr bool find_exists = has_method<const S, Result<std::vector<Vertex<typename S::InputTrack_t>>>, find_t, const std::vector<const typename S::InputTrack_t*>&, constVertexingOptions<typename S::InputTrack_t>&, typename S::State&>
-
using state_t = typename T::State
-
namespace VertexFitter
Typedefs
-
using linearizer_t = typename T::Linearizer_t
-
using propagator_t = typename T::Propagator_t
-
using state_t = typename T::State
-
using track_t = typename T::InputTrack_t
Functions
-
METHOD_TRAIT(fit_t, fit)
-
template<typename S>
struct VertexFitterConcept - #include <Acts/Vertexing/VertexFitterConcept.hpp>
Public Static Attributes
-
static constexpr bool fit_exists = has_method<const S, Result<Vertex<typename S::InputTrack_t>>, fit_t, const std::vector<const typename S::InputTrack_t*>&, const typename S::Linearizer_t&, constVertexingOptions<typename S::InputTrack_t>&, typename S::State&>
-
static constexpr bool linearizer_exists = exists<linearizer_t, S>
-
static constexpr bool propagator_exists = exists<propagator_t, S>
-
static constexpr bool value = require<fit_exists, track_exists, propagator_exists, linearizer_exists, state_exists>
-
static constexpr bool fit_exists = has_method<const S, Result<Vertex<typename S::InputTrack_t>>, fit_t, const std::vector<const typename S::InputTrack_t*>&, const typename S::Linearizer_t&, constVertexingOptions<typename S::InputTrack_t>&, typename S::State&>
-
using linearizer_t = typename T::Linearizer_t
-
using detected_or = detail::detector<Default, void, Op, Args...>
-
namespace HashedStringLiteral
Functions
-
constexpr HashedString operator""_hash(char const *s, std::size_t count)
-
constexpr HashedString operator""_hash(char const *s, std::size_t count)
-
namespace KalmanVertexTrackUpdater
Functions
-
template<typename input_track_t>
void update(TrackAtVertex<input_track_t> &track, const Vertex<input_track_t> &vtx) KalmanVertexTrackUpdater.
Refits a single track with the knowledge of the vertex it has originated from
- Parameters
track – Track to update
vtx – Vertex
track
belongs to
-
template<typename input_track_t>
-
namespace KalmanVertexUpdater
Functions
-
template<typename input_track_t>
void updatePosition(const Acts::Vertex<input_track_t> &vtx, const Acts::LinearizedTrack &linTrack, double trackWeight, int sign, MatrixCache &matrixCache) Updates vertex position.
- Parameters
vtx – Old vertex
linTrack – Linearized version of track to be added or removed
trackWeight – Track weight
sign – +1 (add track) or -1 (remove track)
matrixCache – [out] A cache to store matrix information
-
template<typename input_track_t>
void updateVertexWithTrack(Vertex<input_track_t> &vtx, TrackAtVertex<input_track_t> &trk) Updates vertex with knowledge of new track.
Note
KalmanVertexUpdater updates the vertex w.r.t. the newly given track, but does NOT add the track to the TrackAtVertex list. Has to be done manually after calling this method
- Parameters
vtx – Vertex to be updated
trk – Track to be used for updating the vertex
-
struct MatrixCache
- #include <Acts/Vertexing/KalmanVertexUpdater.hpp>
KalmanVertexUpdater.
adds or removes track from or updates current vertex Based on R. Frühwirth et al. Vertex reconstruction and track bundling at the lep collider using robust Algorithms Computer Physics Comm.: 96 (1996) 189, chapter 2.1 Cache object to store matrix information
Public Members
-
SymMatrix3 momWeightInv = SymMatrix3::Zero()
-
SymMatrix3 newVertexCov = SymMatrix3::Zero()
-
SymMatrix3 newVertexWeight = SymMatrix3::Zero()
-
SymMatrix3 oldVertexWeight = SymMatrix3::Zero()
-
SymMatrix3 momWeightInv = SymMatrix3::Zero()
-
template<typename input_track_t>
-
namespace Legacy
-
template<typename SpacePoint>
class AtlasSeedfinder - #include <Acts/Seeding/AtlasSeedfinder.hpp>
Public Functions
-
AtlasSeedfinder()
-
virtual ~AtlasSeedfinder()
-
void find3Sp()
-
inline const Seed<SpacePoint> *next()
Public Members
-
const Config m_config
-
AtlasSeedfinder()
-
class comCurvature
- #include <Acts/Seeding/AtlasSeedfinder.hpp>
Public Functions
-
template<typename SpacePoint>
inline bool operator()(const std::pair<float, Acts::Legacy::SPForSeed<SpacePoint>*> &i1, const std::pair<float, Acts::Legacy::SPForSeed<SpacePoint>*> &i2)
-
template<typename SpacePoint>
-
template<typename SpacePoint>
class InternalSeed - #include <Acts/Seeding/LegacyInternalSeed.hpp>
Public Functions
-
InternalSeed()
-
InternalSeed(SPForSeed<SpacePoint>*&, SPForSeed<SpacePoint>*&, SPForSeed<SpacePoint>*&, float)
-
InternalSeed(const InternalSeed<SpacePoint>&)
-
virtual ~InternalSeed()
-
InternalSeed<SpacePoint> &operator=(const InternalSeed<SpacePoint>&)
-
inline const float &quality() const
-
void set(SPForSeed<SpacePoint>*&, SPForSeed<SpacePoint>*&, SPForSeed<SpacePoint>*&, float)
-
bool set3(Acts::Legacy::Seed<SpacePoint>&)
-
bool setQuality(float)
-
inline SPForSeed<SpacePoint> *spacepoint0()
-
inline SPForSeed<SpacePoint> *spacepoint1()
-
inline SPForSeed<SpacePoint> *spacepoint2()
-
inline const float &z() const
-
InternalSeed()
-
template<typename SpacePoint>
class Seed - #include <Acts/Seeding/LegacySeed.hpp>
Public Functions
-
Seed()
-
Seed(const SpacePoint*, const SpacePoint*, const SpacePoint*, const double)
-
Seed(const Seed&)
-
virtual ~Seed()
-
void add(const SpacePoint*&)
-
void erase()
-
void setZVertex(const double&)
-
const std::list<const SpacePoint*> &spacePoints() const
-
const double &zVertex() const
-
Seed()
-
template<typename SpacePoint>
class SPForSeed - #include <Acts/Seeding/SPForSeed.hpp>
Public Functions
-
inline SPForSeed()
-
inline SPForSeed(SpacePoint*const&, const float*)
-
inline SPForSeed(SpacePoint*const&, const float*, const float*)
-
inline SPForSeed(const SPForSeed&)
-
inline virtual ~SPForSeed()
-
inline const float &covr() const
-
inline const float &covz() const
-
inline const float ¶m() const
-
inline float phi() const
-
inline const float &quality() const
-
inline const float &radius() const
-
inline void set(SpacePoint*const&, const float*)
-
inline void set(SpacePoint*const&, const float*, const float*)
-
inline void setParam(const float&)
-
inline void setQuality(float)
-
inline const int &surface() const
-
inline const float &x() const
-
inline const float &y() const
-
inline const float &z() const
Public Members
-
const SpacePoint *spacepoint
-
inline SPForSeed()
-
template<typename SpacePoint>
-
namespace Logging
debug output related helper classes and functions
Enums
-
enum Level
constants steering the debug output
All messages with a debug level equal or higher than the currently set debug output level will be printed.
Values:
-
enumerator VERBOSE
VERBOSE level.
-
enumerator DEBUG
DEBUG level.
-
enumerator INFO
INFO level.
-
enumerator WARNING
WARNING level.
-
enumerator ERROR
ERROR level.
-
enumerator FATAL
FATAL level.
-
enumerator MAX
Must be kept above the maximum supported debug level.
-
enumerator VERBOSE
Functions
-
Level getFailureThreshold()
Get debug level above which an exception will be thrown after logging.
All messages with a debug level equal or higher than the return value of this function will cause an exception to be thrown after log emission.
Note
Depending on preprocessor settings
ACTS_ENABLE_LOG_FAILURE_THRESHOLD
andACTS_LOG_FAILURE_THRESHOLD
, this operations is either constexpr or a runtime operation.
-
inline std::string_view levelName(Level level)
-
void setFailureThreshold(Level level)
Set debug level above which an exception will be thrown after logging.
All messages with a debug level equal or higher than
level
will cause an exception to be thrown after log emission.Note
This function is only available if
ACTS_LOG_FAILURE_THRESHOLD
is unset, i.e. no compile-time threshold is used. Otherwise an exception is thrown.Warning
The runtime log failure threshold is global state, therefore this function is not threadsafe. The intention is that this level is set once, before multi-threaded execution begins, and then not modified before the end of the job.
-
class DefaultFilterPolicy : public Acts::Logging::OutputFilterPolicy
- #include <Acts/Utilities/Logger.hpp>
default filter policy for debug messages
All debug messages with a debug level equal or larger to the specified threshold level are processed.
Public Functions
-
inline explicit DefaultFilterPolicy(const Level &lvl)
constructor
- Parameters
lvl – [in] threshold debug level
-
~DefaultFilterPolicy() override = default
virtual default destructor
-
inline virtual bool doPrint(const Level &lvl) const override
decide whether a debug message should be processed
- Parameters
lvl – [in] debug level of debug message
- Returns
true
iflvl
>= m_level, otherwisefalse
-
inline explicit DefaultFilterPolicy(const Level &lvl)
-
class DefaultPrintPolicy : public Acts::Logging::OutputPrintPolicy
- #include <Acts/Utilities/Logger.hpp>
default print policy for debug messages
This class allows to print debug messages without further modifications to a specified output stream.
Public Functions
-
inline explicit DefaultPrintPolicy(std::ostream *out = &std::cout)
constructor
- Parameters
out – [in] pointer to output stream object
- Pre
out
is non-zero
-
inline virtual void flush(const Level &lvl, const std::string &input) final
flush the debug message to the destination stream
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline explicit DefaultPrintPolicy(std::ostream *out = &std::cout)
-
class LevelOutputDecorator : public Acts::Logging::OutputDecorator
- #include <Acts/Utilities/Logger.hpp>
decorate debug message with its debug level
The debug message is complemented with its debug level.
Public Functions
-
inline explicit LevelOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
constructor
- Parameters
wrappee – [in] output print policy object to be wrapped
-
inline virtual void flush(const Level &lvl, const std::string &input) override
flush the debug message to the destination stream
This function prepends the debug level to the debug message and then delegates the flushing of the whole message to its wrapped object.
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline explicit LevelOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
-
class NamedOutputDecorator : public Acts::Logging::OutputDecorator
- #include <Acts/Utilities/Logger.hpp>
decorate debug message with a name
The debug message is complemented with a name.
Public Functions
-
inline NamedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &name, unsigned int maxWidth = 15)
constructor
- Parameters
wrappee – [in] output print policy object to be wrapped
name – [in] name to be added to debug message
maxWidth – [in] maximum width of field used for name
-
inline virtual void flush(const Level &lvl, const std::string &input) override
flush the debug message to the destination stream
This function prepends the given name to the debug message and then delegates the flushing of the whole message to its wrapped object.
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline NamedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &name, unsigned int maxWidth = 15)
-
class OutputDecorator : public Acts::Logging::OutputPrintPolicy
- #include <Acts/Utilities/Logger.hpp>
base class for decorating the debug output
Derived classes may augment the debug message with additional information. Chaining different decorators is possible to customize the output to your needs.
Subclassed by Acts::Logging::LevelOutputDecorator, Acts::Logging::NamedOutputDecorator, Acts::Logging::ThreadOutputDecorator, Acts::Logging::TimedOutputDecorator
Public Functions
-
inline explicit OutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
constructor wrapping actual output print policy
- Parameters
wrappee – [in] output print policy object which is wrapped by this decorator object
-
inline virtual void flush(const Level &lvl, const std::string &input) override
flush the debug message to the destination stream
This function delegates the flushing of the debug message to its wrapped object.
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline explicit OutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
-
class OutputFilterPolicy
- #include <Acts/Utilities/Logger.hpp>
abstract base class for filtering debug output
Implementations of this interface need to define whether a debug message with a certain debug level is processed or filtered out.
Subclassed by Acts::Logging::DefaultFilterPolicy
Public Functions
-
virtual ~OutputFilterPolicy() = default
virtual default destructor
-
virtual bool doPrint(const Level &lvl) const = 0
decide whether a debug message should be processed
- Parameters
lvl – [in] debug level of debug message
- Returns
true
of debug message should be processed,false
if debug message should be skipped
-
virtual ~OutputFilterPolicy() = default
-
class OutputPrintPolicy
- #include <Acts/Utilities/Logger.hpp>
abstract base class for printing debug output
Implementations of this interface need to define how and where to print debug messages (e.g. to a file, to a stream into a database etc).
Subclassed by Acts::Logging::DefaultPrintPolicy, Acts::Logging::OutputDecorator
Public Functions
-
virtual ~OutputPrintPolicy() = default
virtual default destructor
-
virtual void flush(const Level &lvl, const std::string &input) = 0
handle output of debug message
- Parameters
lvl – [in] debug output level of message
input – [in] text of debug message
-
virtual ~OutputPrintPolicy() = default
-
class ThreadOutputDecorator : public Acts::Logging::OutputDecorator
- #include <Acts/Utilities/Logger.hpp>
decorate debug message with a thread ID
The debug message is complemented with a thread ID.
Public Functions
-
inline explicit ThreadOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
constructor
- Parameters
wrappee – [in] output print policy object to be wrapped
-
inline virtual void flush(const Level &lvl, const std::string &input) override
flush the debug message to the destination stream
This function prepends the thread ID to the debug message and then delegates the flushing of the whole message to its wrapped object.
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline explicit ThreadOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
-
class ThresholdFailure : public std::runtime_error
- #include <Acts/Utilities/Logger.hpp>
Custom exception class so threshold failures can be caught.
-
class TimedOutputDecorator : public Acts::Logging::OutputDecorator
- #include <Acts/Utilities/Logger.hpp>
decorate debug message with a time stamp
The debug message is complemented with a time stamp.
Public Functions
-
inline TimedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &format = "%X")
constructor
- Parameters
wrappee – [in] output print policy object to be wrapped
format – [in] format of time stamp (see std::strftime)
-
inline virtual void flush(const Level &lvl, const std::string &input) override
flush the debug message to the destination stream
This function prepends a time stamp to the debug message and then delegates the flushing of the whole message to its wrapped object.
- Parameters
lvl – [in] debug level of debug message
input – [in] text of debug message
-
inline TimedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &format = "%X")
-
enum Level
-
namespace MultiTrajectoryHelpers
Typedefs
-
using VolumeTrajectoryStateContainer = std::unordered_map<GeometryIdentifier::Value, TrajectoryState>
Functions
-
template<typename track_state_proxy_t>
FreeVector freeFiltered(const GeometryContext &gctx, const track_state_proxy_t &trackStateProxy) Transforms the filtered parameters from a
TrackStateProxy
to free parameters.- Template Parameters
track_state_proxy_t – Type of the
TrackStateProxy
- Parameters
gctx – [in] Geometry context
trackStateProxy – [in] TrackStateProxy
- Returns
Free parameters representation of the filtered parameters
-
template<typename track_state_proxy_t>
FreeVector freeSmoothed(const GeometryContext &gctx, const track_state_proxy_t &trackStateProxy) Transforms the smoothed parameters from a
TrackStateProxy
to free parameters.- Template Parameters
track_state_proxy_t – Type of the
TrackStateProxy
- Parameters
gctx – [in] Geometry context
trackStateProxy – [in] TrackStateProxy
- Returns
Free parameters representation of the smoothed parameters
-
template<typename traj_t>
TrajectoryState trajectoryState(const Acts::MultiTrajectory<traj_t> &multiTraj, const size_t &entryIndex) Getter for global trajectory info.
- Template Parameters
source_link_t – Type of source link
- Parameters
multiTraj – The MultiTrajectory object
entryIndex – The entry index of trajectory to investigate
- Returns
The trajectory summary info
-
template<typename traj_t>
VolumeTrajectoryStateContainer trajectoryState(const Acts::MultiTrajectory<traj_t> &multiTraj, const size_t &entryIndex, const std::vector<GeometryIdentifier::Value> &volumeIds) Getter for trajectory info for different sub-detectors.
- Template Parameters
source_link_t – Type of source link
- Parameters
multiTraj – The MultiTrajectory object
entryIndex – The entry index of trajectory to investigate track states at different sub-detectors.
volumeIds – The container for sub-detector Ids
- Returns
The trajectory summary info at different sub-detectors (i.e. different volumes)
-
struct TrajectoryState
- #include <Acts/EventData/MultiTrajectoryHelpers.hpp>
Struct for brief trajectory summary info.
Public Members
-
double chi2Sum = 0
-
std::vector<double> measurementChi2 = {}
-
std::vector<unsigned int> measurementLayer = {}
-
std::vector<unsigned int> measurementVolume = {}
-
size_t NDF = 0
-
size_t nHoles = 0
-
size_t nMeasurements = 0
-
size_t nOutliers = 0
-
size_t nStates = 0
-
std::vector<double> outlierChi2 = {}
-
std::vector<unsigned int> outlierLayer = {}
-
std::vector<unsigned int> outlierVolume = {}
-
double chi2Sum = 0
-
using VolumeTrajectoryStateContainer = std::unordered_map<GeometryIdentifier::Value, TrajectoryState>
-
namespace MultiTrajectoryTraits
This namespace contains typedefs and constant values that are used by other parts of the
MultiTrajectory
implementation.It extracts these from
TrackStateTraits
using the default maximum measurement dimension.Typedefs
-
using IndexType = TrackStateTraits<MeasurementSizeMax, true>::IndexType
Variables
-
constexpr IndexType kInvalid = TrackStateTraits<MeasurementSizeMax, true>::kInvalid
-
constexpr unsigned int MeasurementSizeMax = eBoundSize
-
using IndexType = TrackStateTraits<MeasurementSizeMax, true>::IndexType
-
namespace PhysicalConstants
Physical constants in native units.
Unit constants are intentionally not listed.
Variables
-
constexpr double hbar = 6.582119569509066e-25 * UnitConstants::GeV * UnitConstants::s
Reduced Planck constant h/2*pi.
Computed from CODATA 2018 constants to double precision.
-
constexpr double hbar = 6.582119569509066e-25 * UnitConstants::GeV * UnitConstants::s
-
namespace Test
-
namespace UnitConstants
All physical quantities have both a numerical value and a unit. For the computations we always choose a particular unit for a given physical quantity so we only need to consider the numerical values as such. The chosen base unit for a particular physical dimension, e.g. length, time, or energy, within this code base is called the native unit. The base units should be chosen such that they are internally consistent, require the least amount of explicit conversion factors (ideally none at all), and have typical numerical values close to unity to reduce numerical issues.
Here, the following native units are used:
Length is expressed in mm.
Time is expressed in [speed-of-light * time] == mm. A consequence of this choice is that the speed-of-light expressed in native units is 1.
Angles are expressed in radian.
Energy, mass, and momentum are all expressed in GeV (consistent with speed-of-light == 1).
Electric charge is expressed in e, i.e. units of the elementary charge.
The magnetic field is expressed in GeV/(e*mm). The magnetic field connects momentum to length, e.g. in SI units the radius of a charged particle trajectory in a constant magnetic field is given by
\[radius = - (momentum / charge) / field\]With the chosen magnetic field unit the expression above stays the same and no additional conversion factors are necessary.
Amount of substance is expressed in mol.
Depending on the context a physical quantity might not be given in the native units. In this case we need to convert to the native unit first before the value can be used. The necessary conversion factors are defined in
Acts::UnitConstants
. Multiplying a value with the unit constant produces the equivalent value in the native unit, e.g.double length = 1 * Acts::UnitConstants::m; // length == 1000.0 double momentum = 100 * Acts::UnitConstants::MeV; // momentum == 0.1
The conversion of a value in native units into the equivalent value in a specific other unit is computed by dividing with the relevant unit, e.g.
double length = 10.0; // native units mm double lengthInM = length / Acts::UnitConstants::m; // == 0.01;
To further simplify the usage, physical quantities can also be expressed via C++ user literals defined in
Acts::UnitLiterals
. This allows us to express quantities in a concise way:using namespace Acts::UnitLiterals; double length = 1_m; // == 1000.0 double momentum = 1.25_TeV; // == 1250.0 double lengthInUm = length / 1_um; // == 1000000.0 double momentumInMeV = momentum / 1_MeV; // == 1250000.0
To ensure consistent computations and results the following guidelines must be followed when handling physical quantities with units:
All unqualified numerical values, i.e. without a unit, are assumed to be expressed in the relevant native unit, e.g. mm for lengths or GeV for energy/momentum.
If a variable stores a physical quantity in a specific unit that is not the native unit, clearly mark this in the variable, i.e.
double momentum = 100.0; // momentum is stored as native unit GeV double momentumInMeV = 10.0; // would be 0.01 in native units
All input values must be given as
numerical_value * unit_constant
or equivalently using the unit literals asvalue_unit
. The resulting unqualified numerical value will be automatically converted to the native unit.To output an unqualified numerical value in the native units as a numerical value in a specific unit divide by the unit constants as
numerical_value / unit_constant
or using the unit literals asvalue / 1_unit
.
Examples:
#include <Acts/include/Definitions/Units.hpp> using namespace Acts::UnitLiterals; // define input values w/ units (via unit constants) double width = 12 * Acts::UnitConstants::mm; double mmuon = 105.7 * Acts::UnitConstants::MeV; // define input values w/ units (via unit user literals) double length = 23_cm; double time = 1214.2_ns; double angle = 123_degree; double momentum = 2.5_TeV; double mass = 511_keV; double velocity = 345_m / 1_s; double bfield = 3.9_T; // convert output values (via unit constants) doube t_in_ns = trackPars.time() / Acts::UnitConstants::ns; // convert output values (via unit user literals) double x_in_mm = trackPars.position()[ePos0] / 1_mm; double p_in_TeV = trackPars.absoluteMomentum() / 1_TeV;
Note
A helper script is available in
Core/scripts/print_units_physical_constants.py
to validate some of the numerical values.Warning
Since using user-defined literals requires a namespace import of
Acts::UnitLiterals
it should not be used in headers since it would (accidentally) modify the namespace wherever the header is included.Variables
-
constexpr double cm = 10.0
-
constexpr double degree = 0.017453292519943295
-
constexpr double e = 1.0
-
constexpr double eV = 1e-9
-
constexpr double fm = 1e-12
-
constexpr double fs = 1e-15 * s
-
constexpr double g = 1.0 / 1.782662e-24
-
constexpr double Gauss = 1e-4 * T
-
constexpr double GeV = 1.0
-
constexpr double h = 3600.0 * s
-
constexpr double J = 6241509074.460763 * GeV
-
constexpr double keV = 1e-6
-
constexpr double kg = 1.0 / 1.782662e-27
-
constexpr double kGauss = 1e-1 * T
-
constexpr double km = 1e6
-
constexpr double m = 1e3
-
constexpr double MeV = 1e-3
-
constexpr double min = 60.0 * s
-
constexpr double mm = 1.0
-
constexpr double mol = 1.0
-
constexpr double mrad = 1e-3
-
constexpr double ms = 1e-3 * s
-
constexpr double nm = 1e-6
-
constexpr double ns = 1e-9 * s
-
constexpr double pm = 1e-9
-
constexpr double ps = 1e-12 * s
-
constexpr double rad = 1.0
-
constexpr double s = 299792458000.0
-
constexpr double T = 0.000299792458
-
constexpr double TeV = 1e3
-
constexpr double u = 0.93149410242
-
constexpr double um = 1e-3
-
constexpr double us = 1e-6 * s
-
namespace UnitLiterals
-
namespace VectorHelpers
Functions
-
inline double cast(const Vector3 &position, BinningValue bval)
Helper method to extract the binning value from a 3D vector.
For this method a 3D vector is required to guarantee all potential binning values.
-
inline ActsMatrix<3, 3> cross(const ActsMatrix<3, 3> &m, const Vector3 &v)
Calculates column-wise cross products of a matrix and a vector and stores the result column-wise in a matrix.
- Parameters
m – [in] Matrix that will be used for cross products
v – [in] Vector for cross products
- Returns
Constructed matrix
-
template<typename Derived>
double eta(const Eigen::MatrixBase<Derived> &v) noexcept Calculate the pseudorapidity for a vector.
Note
Will static assert that the number of rows of
v
is at least 3, or in case of dynamic size, will abort execution if that is not the case.- Template Parameters
Derived – Eigen derived concrete type
- Parameters
v – Any vector like Eigen type, static or dynamic
- Returns
The pseudorapidity value
-
static inline const std::array<ActsScalar, 5> evaluateTrigonomics(const Vector3 &direction)
Fast evaluation of trigonomic functions.
- Parameters
direction – for this evaluatoin
- Returns
cos(phi), sin(phi), cos(theta), sin(theta), 1/sin(theta)
-
template<typename vector3_t>
inline auto makeVector4(const Eigen::MatrixBase<vector3_t> &vec3, typename vector3_t::Scalar w) -> Eigen::Matrix<typename vector3_t::Scalar, 4, 1> Construct a four-vector from a three-vector and scalar fourth component.
-
template<typename Derived>
double perp(const Eigen::MatrixBase<Derived> &v) noexcept Calculate radius in the transverse (xy) plane of a vector.
Note
Will static assert that the number of rows of
v
is at least 2, or in case of dynamic size, will abort execution if that is not the case.- Template Parameters
Derived – Eigen derived concrete type
- Parameters
v – Any vector like Eigen type, static or dynamic
- Returns
The transverse radius value.
-
template<typename Derived>
double phi(const Eigen::MatrixBase<Derived> &v) noexcept Calculate phi (transverse plane angle) from compatible Eigen types.
Note
Will static assert that the number of rows of
v
is at least 2, or in case of dynamic size, will abort execution if that is not the case.- Template Parameters
Derived – Eigen derived concrete type
- Parameters
v – Any vector like Eigen type, static or dynamic
- Returns
The value of the angle in the transverse plane.
-
template<typename T, std::enable_if_t<detail::has_phi_method<T>::value, int> = 0>
double phi(const T &v) noexcept Calculate phi (transverse plane angle) from anything implementing a method like
phi()
returing anything convertible todouble
.- Template Parameters
T – anything that has a phi method
- Parameters
v – Any type that implements a phi method
- Returns
The phi value
-
inline auto position(const Vector4 &pos4)
Access the three-position components in a four-position vector.
-
inline auto position(const FreeVector ¶ms)
Access the three-position components in a free parameters vector.
-
template<typename Derived>
double theta(const Eigen::MatrixBase<Derived> &v) noexcept Calculate the theta angle (longitudinal w.r.t.
z axis) of a vector
Note
Will static assert that the number of rows of
v
is at least 3, or in case of dynamic size, will abort execution if that is not the case.- Template Parameters
Derived – Eigen derived concrete type
- Parameters
v – Any vector like Eigen type, static or dynamic
- Returns
The theta value
-
inline double cast(const Vector3 &position, BinningValue bval)
-
using ActsDynamicMatrix = Eigen::Matrix<ActsScalar, Eigen::Dynamic, Eigen::Dynamic>