Namespace Acts¶

namespace Acts

Set the Geometry Context PLUGIN.

Set the Calibration Context PLUGIN.

Convenience functions to ease creation of and Acts::InterpolatedMaterialMap and to avoid code duplication.

Set the Mangetic Field Context PLUGIN.

Convenience functions to ease creation of and Acts::InterpolatedBFieldMap and to avoid code duplication.

Currently implemented for the two most common formats: rz and xyz.

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 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 Grid2D = Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis>

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

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 MaterialGrid2D = Acts::detail::Grid<Acts::Material::ParametersVector, EAxis, EAxis>

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

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 NextLayers = std::pair<const Layer*, const Layer*>

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

using OrientedSurfaces = std::vector<OrientedSurface>

using ProjectorBitset = std::bitset<eBoundSize * eBoundSize>

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

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 scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Values:

enumerator eAlignmentCenter0

enumerator eAlignmentCenter1

enumerator eAlignmentCenter2

enumerator eAlignmentRotation0

enumerator eAlignmentRotation1

enumerator eAlignmentRotation2

enumerator eAlignmentSize

enum BinningOption

flag for open/closed bins

Values:

enumerator open

enumerator closed

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

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

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 scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Values:

enumerator eBoundLoc0

enumerator eBoundLoc1

enumerator eBoundPhi

enumerator eBoundTheta

enumerator eBoundQOverP

enumerator eBoundTime

enumerator eBoundSize

enum CombinatorialKalmanFilterError

Values:

enumerator UpdateFailed

enumerator SmoothFailed

enumerator OutputConversionFailed

enumerator MeasurementSelectionFailed

enumerator NoTrackFound

enumerator PropagationReachesMaxSteps

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 scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts.

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

Values:

enumerator ePos0

enumerator ePos1

enumerator ePos2

enumerator eTime

enumerator eMom0

enumerator eMom1

enumerator eMom2

enumerator eEnergy

enumerator eX

enumerator eY

enumerator eZ

enum EigenStepperError

Values:

enumerator StepSizeStalled

enumerator StepInvalid

enumerator StepSizeAdjustmentFailed

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 scoped enum class to allow implicit conversion to an integer. The enum value are thus visible directly in namespace Acts and are prefixed to avoid naming collisions.

Values:

enumerator eFreePos0

enumerator eFreePos1

enumerator eFreePos2

enumerator eFreeTime

enumerator eFreeDir0

enumerator eFreeDir1

enumerator eFreeDir2

enumerator eFreeQOverP

enumerator eFreeSize

enum GsfError

Values:

enumerator NavigationFailed

enumerator ComponentNumberMismatch

enumerator AllComponentsSteppingError

enumerator NoComponentCreated

enumerator NoStatesCreated

enumerator StartParametersNotOnStartSurface

enumerator PropagationEndedOnWrongSurface

enumerator LastStepParamsContainNan

enumerator SmoothingFailed

enum IntersectionStatus

Status enum.

Values:

enumerator missed

enumerator unreachable

enumerator reachable

enumerator onSurface

enum KalmanFitterError

Values:

enumerator ForwardUpdateFailed

enumerator BackwardUpdateFailed

enumerator SmoothFailed

enumerator OutputConversionFailed

enumerator NoMeasurementFound

enumerator ReverseNavigationFailed

enum LayerType

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

Values:

enumerator navigation

enumerator passive

enumerator active

enum MagneticFieldError

Values:

enumerator OutOfBounds

enum MappingType

This enum describes the type of surface material mapping.

Values:

enumerator PreMapping

enumerator Default

enumerator PostMapping

enumerator Sensor

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

enum NavigationDirection

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

Values:

enumerator Backward

enumerator Forward

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

enum PropagatorError

Values:

enumerator Failure

enumerator WrongDirection

enumerator StepCountLimitReached

enum SurfaceError

Values:

enumerator GlobalPositionNotOnSurface

enum TrackStateFlag

This enum describes the type of TrackState.

Values:

enumerator MeasurementFlag

enumerator ParameterFlag

enumerator OutlierFlag

enumerator HoleFlag

enumerator MaterialFlag

enumerator SharedHitFlag

enumerator NumTrackStateFlags

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 Uncalibrated

enumerator Calibrated

enumerator All

enum VertexingError

Values:

enumerator NumericFailure

enumerator EmptyInput

enumerator SeedingError

enumerator NotConverged

enumerator ElementNotFound

enumerator NoCovariance

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

Functions

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

Helper method to translate DD4hep material to Acts::ISurfaceMaterial.

This is used to assign proto material to Cylinder Layers

Parameters

detElement – the DD4hep detector element for which this material is assigned
cylinderLayer – is the target layer
loggingLevel – is the output level for the conversion

void addDiscLayerProtoMaterial(dd4hep::DetElement detElement, Layer &discLayer, Logging::Level loggingLevel = Logging::Level::INFO)

Helper method to translate DD4hep material to Acts::ISurfaceMaterial.

Thisis used to assign proto material to Disc Layers

Parameters

detElement – the DD4hep detector element for which this material is assigned
discLayer – is the target layer
loggingLevel – is the output level for the conversion

void addLayerProtoMaterial(const ActsExtension &actsExtension, Layer &layer, const std::vector<std::pair<const std::string, Acts::BinningOption>> &binning)

Helper method to be called for Cylinder and Disc Proto material.

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

Parameters

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

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)

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

void collectSubDetectors_dd4hep(dd4hep::DetElement &detElement, std::vector<dd4hep::DetElement> &subdetectors)

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

Parameters

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

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

Method internally used by convertDD4hepDetector.

Parameters

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

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

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

Global method which creates the TrackingGeometry from DD4hep input.

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 method collectSubDetectors() ) from bottom to top to ensure correct wrapping of the volumes, which is needed for navigation. Therefore the different hierachies need to be sorted ascending. The default is sorting by ID.
gctx – The geometry context to use
matDecorator – is the material decorator that loads material maps

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 ActsExtension &actsExtension, const std::string &valueTag, const std::vector<std::pair<const std::string, Acts::BinningOption>> &binning)

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

Parameters

actsExtension – the ActExtension to be checked
valueTag – the xml tag for to ActsExtension to be parsed
binning – the Binning prescription for the ActsExtension

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

In this case the function would look like:

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

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

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 and that the BFieldMap should be created symmetrically for all quadrants. e.g. we have the grid values r={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the r-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.

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

In this case the function would look like:

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

Note

The 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 magnetic field was stored in the vector in respect to the grid values

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 and that the BFieldMap should be created symmetrically for all quadrants. e.g. we have the grid values z={0,1} with BFieldValues={2,3} on the r axis. If the flag is set to true the z-axis grid values will be set to {-1,0,1} and the BFieldValues will be set to {3,2,3}.

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

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

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 and V of value type T as well as two double a and b, then the following must be a valid expression a * U + b * V yielding an object which is (implicitly) convertible to T.
All Point types must represent d-dimensional positions and support coordinate access using operator[] which should return a double (or a value which is implicitly convertible). Coordinate indices must start at 0.
N is the number of hyper box corners which is \(2^d\) where \(d\) is the dimensionality of the hyper box. The dimensionality must be consistent with the provided Point types.
Definition of the canonical order for sorting the field values: The hyper box corners are numbered according to the following scheme. Each corner is defined by the set of lower/upper boundary limits in each dimension i. This can be represented by a binary code (from left to right) where a 0 stands for a lower bound along this axis and a 1
stand for the upper bound along this axis. The left most bit corresponds to the first dimension and the bits to the left correspond to the 2nd, 3rd… dimension. The binary code can be interpreted as integer which gives the number of the corresponding hyper box corner. The field values are ordered according to ascending hyper box corner numbers.

As an example assume we have a 3D box with
lowerCorner = (1,2,3) and upperCorner = (4,5,6). The eight corners with their bit patterns and corner numbers are:
- (1,2,3): 000 = 0
- (1,2,6): 001 = 1
- (1,5,3): 010 = 2
- (1,5,6): 011 = 3
- (4,2,3): 100 = 4
- (4,2,6): 101 = 5
- (4,5,3): 110 = 6
- (4,5,6): 111 = 7

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::KalmanFitterError e)

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

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

std::error_code make_error_code(Acts::GsfError 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 and prims do not need to contain the same objects. store is only used to pass ownership back to the caller while preserving memory location.

Template Parameters

box_t – Works will all box types.

Parameters

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

Returns

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

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 and V for the given direction.

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

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

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

Parameters: direction – is the input direction vector
Returns: normalized unit vectors U and V 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> &params, const Eigen::MatrixBase<covariance_t> &cov, indices_t index0, tail_indices_t... tailIndices) -> Measurement<indices_t, 1u + sizeof...(tail_indices_t)>

Construct a fixed-size measurement for the given indices.

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

In this case the function would look like:

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

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

In this case the function would look like:

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

Note

The 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 constexpr auto operator*(NavigationDirection dir, int value)

inline constexpr auto operator*(NavigationDirection dir, float value)

inline constexpr auto operator*(NavigationDirection dir, double value)

inline Acts::Vector3 operator*(NavigationDirection dir, Acts::Vector3 value)

inline constexpr auto operator*(int value, NavigationDirection dir)

inline constexpr auto operator*(float value, NavigationDirection dir)

inline constexpr auto operator*(double value, NavigationDirection dir)

inline Acts::Vector3 operator*(Acts::Vector3 value, NavigationDirection dir)

inline constexpr auto operator*=(int &value, NavigationDirection dir)

inline constexpr auto operator*=(float &value, NavigationDirection dir)

inline constexpr auto operator*=(double &value, NavigationDirection dir)

inline Acts::Vector3 &operator*=(Acts::Vector3 &value, NavigationDirection dir)

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.

std::ostream &operator<<(std::ostream &os, NavigationDirection navDir)

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 Extent &ext): Overload of << operator for std::ostream for debug output.

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)

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. like std::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 mapper 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

template<typename bounds_t> std::shared_ptr<const bounds_t> surfaceBoundsFromJson(const nlohmann::json &j)

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

template<typename surface_t, typename bounds_t> std::shared_ptr<surface_t> surfaceFromJsonT(const nlohmann::json &j)

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 between N and NMAX, attempting to find the right instance. Because the cascade is visible to the compiler entirely, it should be able to optimize.

Note

Callable is expected to have a static member function invoke that is callable with Args

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)

void to_json(nlohmann::json &j, std::shared_ptr<const Surface> surface): 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

void toJson(nlohmann::json &j, std::shared_ptr<const Surface> surface, const Acts::GeometryContext &gctx)

Contextual conversion of a surface.

Parameters

j – the json to be filled
surface – the surface to be converted
gctx – the geometry context for this

template<typename derived_t> 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 &parameters, CovarianceCache &cCache)

Transport the covariance to a new (surface) bound definition.

Parameters

gctx – [in] The current geometry context
surface – [in] The surface of the bound representation
parameters – [in] The free parametrisation on the surface
cCache – [in,out] the covariance cache (to be modified)

Returns

a variant transport jacobian

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)

template<typename T> std::vector<T*> unpack_shared_vector(const std::vector<std::shared_ptr<T>> &items)

Helper function to unpack a vector of shared_ptr into a vector of raw pointers.

Template Parameters: T – the stored type
Parameters: items – The vector of shared_ptr
Returns: The unpacked vector

template<typename T> std::vector<const T*> unpack_shared_vector(const std::vector<std::shared_ptr<const T>> &items)

Helper function to unpack a vector of shared_ptr into a vector of raw pointers (const version)

Template Parameters: T – the stored type
Parameters: items – The vector of shared_ptr
Returns: The unpacked vector

template<typename L, typename A, typename B> auto visit_measurement(A &&param, B &&cov, size_t dim, L &&lambda)

Dispatch a lambda call on an overallocated parameter vector and covariance matrix, based on a runtime dimension value.

Inside the lambda call, the vector and matrix will have fixed dimensions, but will still point back to the originally given overallocated values.

Note

No requirements on A and B 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 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

template<typename ...aborters_t> struct AbortList : public detail::Extendable<aborters_t...>

#include <Acts/Propagator/AbortList.hpp>

AbortList object to be used in the propagation.

The abort list is a list of structs or classes that is called at each propagation step and can trigger the abort of the current propagation.

It can (optionally) depend on a result of an Actor from the actor list.

Public Types

result_type = typename decltype(hana::unpack(detail::type_collector_t< detail::action_type_extractor, aborters_t... >, hana::template_< AbortList >))::type

Public Functions

AbortList() = default: Default constructor.

AbortList(const AbortList<aborters_t...> &aborters) = default

Default copy constructor.

Parameters: aborters – The source action list

AbortList(AbortList<aborters_t...> &&aborters) = default

Default move constructor.

Parameters: aborters – The source action list

inline AbortList(const std::tuple<aborters_t...> &aborters)

Constructor from tuple.

Parameters: aborters – Source extensions tuple

inline AbortList(std::tuple<aborters_t...> &&aborters)

Constructor from tuple move.

Parameters: aborters – Source extensions tuple

template<typename ...appendices_t> inline AbortList<aborters_t..., appendices_t...> append(appendices_t... aps) const: Append new entries and return a new condition.

template<typename result_t, typename propagator_state_t, typename stepper_t> inline bool operator()(const result_t &result, propagator_state_t &state, const stepper_t &stepper) const

This is the call signature for the abort list, it broadcasts the call to the tuple() memembers of the list.

Template Parameters

result_t – is the result type from a certain action
propagator_state_t – is the state type of the propagator
stepper_t – Type of the stepper

Parameters

result – [in] is the result object from a certain action
state – [inout] is the state object from the propagator
stepper – [in] Stepper used for the propagation

AbortList<aborters_t...> &operator=(const AbortList<aborters_t...> &aborters) = default

Default move assignment operator.

Parameters: aborters – The source action list

AbortList<aborters_t...> &operator=(AbortList<aborters_t...> &&aborters) = default

Default move assignment operator.

Parameters: aborters – The source action list

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

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

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.

template<typename ...actors_t> struct ActionList : public detail::Extendable<actors_t...>

#include <Acts/Propagator/ActionList.hpp>

ActionList implementation to be used with the propagator.

This is the ActionList struct that is used in the propagator to define a list of different actors_t that are eacch executed during the stepping procedure

Public Types

result_type = typename decltype(hana::unpack(detail::type_collector_t< detail::result_type_extractor, actors_t... >, hana::template_< R >))::type

Public Functions

ActionList() = default: Default constructor.

ActionList(const ActionList<actors_t...> &actors) = default

Default copy constructor.

Parameters: actors – The source action list

ActionList(ActionList<actors_t...> &&actors) = default

Default move constructor.

Parameters: actors – The source action list

template<typename propagator_state_t, typename stepper_t, typename result_t> inline void operator()(propagator_state_t &state, const stepper_t &stepper, result_t &result) const

Call operator that is that broadcasts the call to the tuple() members of the list.

Template Parameters

propagator_state_t – is the state type of the propagator
stepper_t – Type of the stepper used for the propagation
result_t – is the result type from actions

Parameters

state – [inout] This is the propagator state object
stepper – [in] The stepper in use
result – [inout] This is the result object from actions

ActionList<actors_t...> &operator=(const ActionList<actors_t...> &actors) = default

Default move assignment operator.

Parameters: actors – The source action list

ActionList<actors_t...> &operator=(ActionList<actors_t...> &&actors) = default

Default move assignment operator.

Parameters: actors – The source action list

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

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

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

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

inline Config(vfitter_t fitter, const sfinder_t &sfinder, const ImpactPointEstimator<InputTrack_t, Propagator_t> &ipEst, const Linearizer_t &lin, std::shared_ptr<const MagneticFieldProvider> bIn)

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 invoking fitImpl

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}

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

class AnnealingUtility

#include <Acts/Utilities/AnnealingUtility.hpp>

Implements a deterministic thermodynamic annealing scheme Ref.

(1): CERN-THESIS-2010-027

Public Functions

inline AnnealingUtility(const Config &cfg = Config()): Constructor.

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

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}

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

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.