Namespace Acts

namespace Acts

Note

This file is foreseen for the Geometry module to replace Extent

Typedefs

using ActsDynamicMatrix = Eigen::Matrix<ActsScalar, Eigen::Dynamic, Eigen::Dynamic>
using ActsDynamicVector = Eigen::Matrix<ActsScalar, Eigen::Dynamic, 1>
using ActsMatrix = Eigen::Matrix<ActsScalar, kRows, kCols>
using ActsScalar = double

Common scalar (floating point type used for the default algebra types.

Defaults to double but can be customized by the user.

using ActsSymMatrix = Eigen::Matrix<ActsScalar, kSize, kSize>
using ActsVector = Eigen::Matrix<ActsScalar, kSize, 1>
using AlignmentMatrix = ActsMatrix<eAlignmentSize, eAlignmentSize>
using AlignmentRowVector = ActsMatrix<1, eAlignmentSize>
using AlignmentToBoundMatrix = ActsMatrix<eBoundSize, eAlignmentSize>
using AlignmentToPathMatrix = ActsMatrix<1, eAlignmentSize>
using AlignmentToPositionMatrix = ActsMatrix<3, eAlignmentSize>
using AlignmentVector = ActsVector<eAlignmentSize>
using AngleAxis3 = Eigen::AngleAxis<ActsScalar>
using AxisScalar = Vector3::Scalar
using BoundaryIntersection = ObjectIntersection<BoundarySurface, Surface>

Intersection with a BoundarySurface.

using BoundarySurface = BoundarySurfaceT<TrackingVolume>

BoundarySurface of a volume.

using BoundarySurfacePtr = std::shared_ptr<const BoundarySurfaceT<AbstractVolume>>
using BoundMatrix = ActsMatrix<eBoundSize, eBoundSize>
using BoundSymMatrix = ActsSymMatrix<eBoundSize>
using BoundToFreeMatrix = ActsMatrix<eFreeSize, eBoundSize>
using BoundTrackParameters = SingleBoundTrackParameters<SinglyCharged>
using BoundVariantMeasurement = VariantMeasurement<BoundIndices>

Variant that can hold all possible bound measurements.

using BoundVector = ActsVector<eBoundSize>
using CalibrationContext = std::any

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

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

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

The color typedef.

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

using CurvilinearTrackParameters = SingleCurvilinearTrackParameters<SinglyCharged>
using DefaultExtension = detail::GenericDefaultExtension<double>

A typedef for the default GenericDefaultExtension with double.

using DenseEnvironmentExtension = detail::GenericDenseEnvironmentExtension<double>

A typedef for the default GenericDenseEnvironmentExtension with double.

using EAxis = Acts::detail::EquidistantAxis
using Envelope = std::array<ActsScalar, 2>
using ExtentEnvelope = std::array<std::array<ActsScalar, 2>, binValues>
using FreeMatrix = ActsMatrix<eFreeSize, eFreeSize>
using FreeSymMatrix = ActsSymMatrix<eFreeSize>
using FreeToBoundMatrix = ActsMatrix<eBoundSize, eFreeSize>
using FreeToPathMatrix = ActsMatrix<1, eFreeSize>
using FreeTrackParameters = SingleFreeTrackParameters<SinglyCharged>
using FreeVariantMeasurement = VariantMeasurement<FreeIndices>

Variant that can hold all possible free measurements.

using FreeVector = ActsVector<eFreeSize>
using GeometryContext = ContextType

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

alignment)

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

using Grid2D = Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis>
using Grid3D = Acts::detail::Grid<Acts::AccumulatedVolumeMaterial, EAxis, EAxis, EAxis>
using HashedString = std::uint32_t
using Intersection2D = Intersection<2>
using Intersection3D = Intersection<3>
typedef BinnedArray<LayerPtr> LayerArray

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

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

using LayerIntersection = ObjectIntersection<Layer, Surface>
typedef std::shared_ptr<const Layer> LayerPtr

A std::shared_ptr to a Layer.

typedef std::vector<LayerPtr> LayerVector

A vector of std::shared_ptr to layers.

using MagneticFieldContext = ContextType

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

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

using 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 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 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, LoggerWrapper logger = getDummyLogger())

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

This is used to assign proto material to Cylinder Layers

Parameters
  • detElement – the DD4hep detector element for which this material is assigned

  • cylinderLayer – is the target layer

  • logger – a LoggerWrapper for output

void addDiscLayerProtoMaterial(dd4hep::DetElement detElement, Layer &discLayer, LoggerWrapper logger = getDummyLogger())

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

Thisis used to assign proto material to Disc Layers

Parameters
  • detElement – the DD4hep detector element for which this material is assigned

  • discLayer – is the target layer

  • logger – a LoggerWrapper for output

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

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

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

Parameters
  • params – An instance of DD4hep::VariantParameters

  • layer – the Layer to assign the proto material

  • binning – the Binning prescription for the ActsExtension

  • logger – a LoggerWrapper for output

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

adjust the BinUtility bu to the dimensions of cylinder volume bounds

Parameters
  • bu – BinUtility at source

  • cBounds – the Cylinder volume bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to the dimensions of radial bounds

Parameters
  • bu – BinUtility at source

  • rBounds – the Radial bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to the dimensions of cylinder bounds

Parameters
  • bu – BinUtility at source

  • cBounds – the Cylinder bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

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

Parameters
  • bu – BinUtility at source

  • cBounds – the Cutout Cylinder volume bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to the dimensions of plane bounds

Parameters
  • bu – BinUtility at source

  • pBounds – the Rectangle bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to the dimensions of cuboid volume bounds

Parameters
  • bu – BinUtility at source

  • cBounds – the Cuboid volume bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to the dimensions of plane bounds

Parameters
  • bu – BinUtility at source

  • pBounds – the Trapezoid bounds to adjust to

  • transform – Transform for the adjusted BinUtility

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to a volume

Parameters
  • bu – BinUtility at source

  • volume – Volume to which the adjustment is being done

Returns

new updated BinUtiltiy

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

adjust the BinUtility bu to a surface

Parameters
  • bu – BinUtility at source

  • surface – Surface to which the adjustment is being done

  • gctx – Geometry context to get the surfaces transform

Returns

new updated BinUtiltiy

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

screen output option

template<typename MatrixType>
MatrixType bitsetToMatrix(const std::bitset<MatrixType::RowsAtCompileTime * MatrixType::ColsAtCompileTime> bs)

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

Note

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

Template Parameters

MatrixType – Matrix type that is produced

Parameters

bs – The bitset to convert

Returns

A matrix with the integer values of the bits from bs

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

Perform a blocked matrix multiplication, avoiding Eigen GEMM methods.

Template Parameters
  • A – The type of the first matrix, which should be MxN

  • B – The type of the second matrix, which should be NxP

Parameters
  • a[in] An MxN matrix of type A

  • b[in] An NxP matrix of type P

Returns

The product ab

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

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

Parameters
  • detElement[in] the dd4hep::DetElement of the volume of which the compounds should be collected

  • compounds[out] the DD4hep::DetElements of the compounds contained by detElement

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

Method internally used by convertDD4hepDetector.

Parameters
  • detElement[in] the dd4hep::DetElement of the volume of which the layers should be collected

  • layers[out] the DD4hep::DetElements of the layers contained by detElement

  • logger – a LoggerWrapper for output

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

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

Parameters
  • detElement[in] the dd4hep::DetElement of the volume of which the sub detectors should be collected

  • subdetectors[out] the DD4hep::DetElements of the sub detectors contained by detElement

  • logger – a LoggerWrapper for output

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

Compute the mean energy loss due to ionisation and excitation.

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

Compute the mean energy loss due to ionisation and excitation.

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

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

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

See also

computeEnergyLossBethe for parameters description

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

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

Compute the mean energy loss due to ionisation and excitation.

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

Compute the combined mean energy loss.

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

Compute the combined most probably energy loss.

Compute the combined mean energy loss.

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

Compute the core width of the projected planar scattering distribution.

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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 dd4hep::rec::VariantParameters &params, const std::string &valueTag, const std::vector<std::pair<const std::string, Acts::BinningOption>> &binning, LoggerWrapper logger = getDummyLogger())

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

Parameters
  • params – An instance of DD4hep::VariantParameters

  • valueTag – the xml tag for to ActsExtension to be parsed

  • binning – the Binning prescription for the ActsExtension

  • logger – a LoggerWrapper for output

std::shared_ptr<const CylinderVolumeHelper> cylinderVolumeHelper_dd4hep(Logging::Level loggingLevel = Logging::Level::INFO)

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

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

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

Compute the mean energy loss due to ionisation and excitation.

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

Compute the mean energy loss due to ionisation and excitation.

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

Compute the combined mean energy loss.

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

Compute the combined mean energy loss.

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

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

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

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

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

Parameters
  • slab – The traversed material and its properties

  • pdg – Particle type PDG identifier

  • m – Particle mass

  • qOverP – Particle charge divided by absolute momentum

  • q – Particle charge, only the magnitude is considered

inline constexpr NavigationDirection directionFromStepSize(double value)
template<typename container_type, typename container_type_iter = decltype(std::begin(std::declval<container_type>())), typename = decltype(std::end(std::declval<container_type>()))>
constexpr auto enumerate(container_type &&iterable)

Helper utility to allow indexed enumeration with structured binding.

Usage:

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

with ‘container’ any stl-like container

template<typename spacepoint_iterator_t>
std::optional<BoundVector> estimateTrackParamsFromSeed(spacepoint_iterator_t spBegin, spacepoint_iterator_t spEnd)

Estimate the track parameters on the xy plane from at least three space points.

It assumes the trajectory projection on the xy plane is a circle, i.e. the magnetic field is along global z-axis.

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

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

Template Parameters

spacepoint_iterator_t – The type of space point iterator

Parameters
  • spBegin – is the begin iterator for the space points

  • spEnd – is the end iterator for the space points

Returns

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

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

Estimate the full track parameters from three space points.

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

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

Template Parameters

spacepoint_iterator_t – The type of space point iterator

Parameters
  • gctx – is the geometry context

  • spBegin – is the begin iterator for the space points

  • spEnd – is the end iterator for the space points

  • surface – is the surface of the bottom space point. The estimated bound track parameters will be represented also at this surface

  • bField – is the magnetic field vector

  • bFieldMin – is the minimum magnetic field required to trigger the estimation of q/pt

  • mass – is the estimated particle mass

Returns

optional bound parameters

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

Method to setup the FieldMap.

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

r

i

z

j

B(r,z)

M

2

0

4

0

2.323

0

2

0

5

1

2.334

1

3

1

4

0

2.325

2

3

1

5

1

2.331

3

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()
template<typename T>
T getParam(const std::string &key, dd4hep::DetElement &elt)

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

Template Parameters

T – The value type

Parameters
  • key – The key of the value to extract

  • elt – The detector element instance

Returns

A copy of the value contained in the params instance

template<typename T>
T getParamOr(const std::string &key, const dd4hep::DetElement &elt, T alternative)

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

Template Parameters

T – The value type

Parameters
  • key – The key of the value to extract

  • elt – The detector element instance

  • alternative – The value to return if no params are set of the key doesn’t exist

Returns

The value behind key, or alternative

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

Helper function to extract a VariantParameters instance.

Parameters

elt – The detector element instance

Returns

The VariantParameters instance

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

Helper function to extract a VariantParameters instance, const version.

Parameters

elt – The detector element instance

Returns

The VariantParameters instance

std::function<double(Acts::Vector3)> globalToLocalFromBin(Acts::BinningValue &type)

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

Parameters

type[in] Type of bin

Returns

a coordinate transform function

constexpr HashedString hashString(std::string_view s)
inline bool hasParam(const std::string &key, dd4hep::DetElement &elt)

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

Parameters
  • key – The key to check existance for

  • elt – The detector element instance

Returns

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

inline bool hasParams(dd4hep::DetElement &elt)

Check if a detector element has VariantParameters set.

Parameters

elt – The detector element instance

Returns

True if the VariantParameters exist, false if not

template<typename T, size_t N, class Point1, class Point2 = Point1, class Point3 = Point2, typename = std::enable_if_t<detail::can_interpolate<Point1, Point2, Point3, T>::value>>
inline T interpolate(const Point1 &position, const Point2 &lowerCorner, const Point3 &upperCorner, const std::array<T, N> &values)

performs linear interpolation inside a hyper box

Note

  • Given U 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::MultiStepperError e)
std::error_code make_error_code(Acts::VertexingError e)
std::error_code make_error_code(Acts::KalmanFitterError 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 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 &os, GeometryIdentifier id)
std::ostream &operator<<(std::ostream &sl, const Volume &vol)

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)
std::ostream &operator<<(std::ostream &sl, const Extent &rhs)

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

template<typename indices_t>
std::ostream &operator<<(std::ostream &os, const VariantMeasurement<indices_t> &vm)
std::ostream &operator<<(std::ostream &sl, const BinUtility &bgen)

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

template<typename T, typename U, size_t V>
std::ostream &operator<<(std::ostream &os, const AxisAlignedBoundingBox<T, U, V> &box)

Overload of the << operator for bounding boxes.

Template Parameters
  • T – entity type

  • U – value type

  • V – dimension

Parameters
  • os – The output stream

  • box – The bounding box

Returns

The given output stream.

inline std::ostream &operator<<(std::ostream &os, const std::tuple<const Surface&, const GeometryContext&> &tup)

Print surface information to the provided stream.

Internally invokes the surface.toStream(...)-method. This can be easily used e.g. like std::cout << std::tie(surface, geometryContext);

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 std::vector<BinningValue> s_binningValues = {binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta, binMag}

static list of all binning values

static constexpr ActsScalar s_curvilinearProjTolerance = 0.999995

Tolerance for not being within curvilinear projection this allows using the same curvilinear frame to eta = 6, validity tested with IntegrationTests/PropagationTest.

static constexpr ActsScalar s_epsilon = 3 * std::numeric_limits<ActsScalar>::epsilon()

Tolerance for being numerical equal for geometry building.

static const InfiniteBounds s_noBounds = {}
static constexpr ActsScalar s_onSurfaceTolerance = 1e-4

Tolerance for being on Surface.

Note

This is intentionally given w/o an explicit unit to avoid having to include the units header unneccessarily. With the native length unit of mm this corresponds to 0.1um.

static const Transform3 s_planeXY = Transform3::Identity()
static const Transform3 s_planeYZ = AngleAxis3(0.5 * M_PI, Vector3::UnitY()) * AngleAxis3(0.5 * M_PI, Vector3::UnitZ()) * Transform3::Identity()
static const Transform3 s_planeZX = AngleAxis3(-0.5 * M_PI, Vector3::UnitX()) * AngleAxis3(-0.5 * M_PI, Vector3::UnitZ()) * Transform3::Identity()
static ViewConfig s_viewFiltered = ViewConfig({255, 255, 0})
static ViewConfig s_viewGrid = ViewConfig({220, 0, 0})
static ViewConfig s_viewLine = ViewConfig({0, 0, 220})
static ViewConfig s_viewMeasurement = ViewConfig({255, 102, 0})
static ViewConfig s_viewParameter = ViewConfig({0, 0, 255})
static ViewConfig s_viewPassive = ViewConfig({240, 280, 0})
static ViewConfig s_viewPredicted = ViewConfig({51, 204, 51})
static ViewConfig s_viewSensitive = ViewConfig({0, 180, 240})
static ViewConfig s_viewSmoothed = ViewConfig({0, 102, 255})
static ViewConfig s_viewVolume = ViewConfig({220, 220, 0})
template<typename accessor>
constexpr bool SourceLinkAccessorConcept = Acts::Concepts::SourceLinkAccessor::SourceLinkAccessorConcept<accessor>::value
template<typename stepper, typename state = typename stepper::State>
constexpr bool StepperConcept = Acts::Concepts::Stepper::SingleStepperConcept<stepper, state>::value || Acts::Concepts::Stepper::MultiStepperConcept<stepper, state>::value
template<typename stepper>
constexpr bool StepperStateConcept = Acts::Concepts::Stepper::StepperStateConcept<stepper> || Acts::Concepts::Stepper::MultiStepperStateConcept<stepper>
static std::vector<std::string> surfaceTypes = {"ConeSurface", "CylinderSurface", "DiscSurface", "PerigeeSurface", "PlaneSurface", "StrawSurface", "CurvilinearSurface"}
template<typename finder>
constexpr bool VertexFinderConcept = Acts::Concepts::VertexFinder::VertexFinderConcept<finder>::value
template<typename fitter>
constexpr bool VertexFitterConcept = Acts::Concepts::VertexFitter::VertexFitterConcept<fitter>::value
constexpr Envelope zeroEnvelope = {0., 0}
constexpr ExtentEnvelope zeroEnvelopes = {zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope, zeroEnvelope}
class AbstractVolume : public Acts::Volume
#include <Acts/Geometry/AbstractVolume.hpp>

AbstractVolume description inside the tracking realm.

This is the purely geometrical object volume.

The Acts::AbstractVolume is constructed by giving a pointer to a Transform3 and a pointer to Acts::VolumeBounds, this implies that the ownership of the objects pointed to is passed as well. For memory optimisation, the AbstractVolume can also be constructed with shared_ptr objects.

A Acts::AbstractVolume is at first a collection class of Acts::BoundarySurface, the vector of Acts::BoundarySurface is returned by the Acts::VolumeBounds that carry a decompose method.

Boundary surfaces can be shared between AbstractVolumes to enhance automatic navigation between AbstractVolumes, therefor they are reference counted by a std::shared_ptr holder class.

Public Functions

AbstractVolume(const Transform3 &transform, VolumeBoundsPtr volbounds)

Constructor with shared Transform3*, VolumeBounds*.

Parameters
  • transform – is the gobal 3d transformation into the volume frame

  • volbounds – is the boundary definition

AbstractVolume(const AbstractVolume &vol) = default
AbstractVolume() = delete
~AbstractVolume() override = default
const std::vector<BoundarySurfacePtr> &boundarySurfaces() const

Method to return the BoundarySurfaces.

Returns

the vector of boundary surfaces

AbstractVolume &operator=(const AbstractVolume &vol) = delete
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:

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

  2. 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<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):

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

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

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

Vector2 moduleOrigin() const

Returns moduleOrigin, but rotated out, so averagePhi is already considered.

The module origin needs to consider the rotation introduced by averagePhi

Returns

The origin of the local frame

inline double phiMax() const

Returns the left angular edge of the module.

Returns

The left side angle

inline double phiMin() const

Returns the right angular edge of the module.

Returns

The right side angle

inline virtual double rMax() const final

This method returns outer radius.

inline virtual double rMin() const final

This method returns inner radius.

virtual std::ostream &toStream(std::ostream &sl) const final

Outstream operator.

Parameters

sl – is the ostream to be dumped into

inline virtual SurfaceBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns

is a BoundsType enum

inline virtual std::vector<double> values() const final

Return the bound values as dynamically sized vector.

Returns

this returns a copy of the internal values