API Reference

Classes

class AnnulusBounds : public Acts::DiscBounds

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(const AnnulusBounds &source) = default

AnnulusBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from parameters array.

Parameters:

values – The parameter array

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

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 proceeding 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 BoundaryTolerance &boundaryTolerance) 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)

• boundaryTolerance – 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 BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

virtual std::vector<Vector2> vertices(unsigned int quarterSegments = 2u) const override

This method returns the xy coordinates of the four corners of the bounds in module coordinates (in x/y), and if quarterSegments is bigger or equal to 0, the curved part of the segment is included and approximated by the corresponding number of segments.

Starting from the upper right (max R, pos locX) and proceeding clock-wise i.e. (max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R: neg locX)

Parameters:

quarterSegments – the number of segments used to approximate a quarter of a circle

Returns:

vector for vertices in 2D

class AnyCharge

Charge and momentum interpretation for arbitrarily charged particles.

Only a charge magnitude identical to zero is interpreted as representing a neutral particle. This avoids ambiguities that might arise from using an approximate comparison with an arbitrary epsilon.

Public Functions

inline constexpr AnyCharge(float absQ) noexcept

Construct with the magnitude of the input charge.

inline constexpr AnyCharge(Neutral) noexcept

inline constexpr AnyCharge(SinglyCharged) noexcept

inline constexpr float absQ() const noexcept

inline constexpr float extractCharge(double qOverP) const noexcept

inline constexpr double extractMomentum(double qOverP) const noexcept

inline constexpr double qOverP(double momentum, float signedQ) const noexcept

Friends

inline friend constexpr friend bool operator== (AnyCharge lhs, AnyCharge rhs) noexcept

Compare for equality.

template<int NComponents, int PolyDegree>
class AtlasBetheHeitlerApprox

This class approximates the Bethe-Heitler distribution as a gaussian mixture.

To enable an approximation for continuous input variables, the weights, means and variances are internally parametrized as a Nth order polynomial.

Public Types

using Data = std::array<PolyData, NComponents>

Public Functions

inline constexpr AtlasBetheHeitlerApprox(const Data &lowData, const Data &highData, bool lowTransform, bool highTransform, double lowLimit = 0.1, double highLimit = 0.2, bool clampToRange = false)

Construct the Bethe-Heitler approximation description with two parameterizations, one for lower ranges, one for higher ranges.

Is it assumed that the lower limit of the high-x/x0 data is equal to the upper limit of the low-x/x0 data.

Parameters:

• lowData – data for the lower x/x0 range

• highData – data for the higher x/x0 range

• lowTransform – whether the low data need to be transformed

• highTransform – whether the high data need to be transformed

• lowLimit – the upper limit for the low data

• highLimit – the upper limit for the high data

• clampToRange – whether to clamp the input x/x0 to the allowed range

inline auto mixture(double x) const

Generates the mixture from the polynomials and reweights them, so that the sum of all weights is 1.

Parameters:

x – pathlength in terms of the radiation length

inline constexpr auto numComponents() const

Returns the number of components the returned mixture will have.

inline constexpr bool validXOverX0(double x) const

Checks if an input is valid for the parameterization.

Parameters:

x – pathlength in terms of the radiation length

Public Static Functions

static inline auto loadFromFiles(const std::string &low_parameters_path, const std::string &high_parameters_path, double lowLimit = 0.1, double highLimit = 0.2, bool clampToRange = false)

Loads a parameterization from a file according to the Atlas file description.

Parameters:

• low_parameters_path – Path to the foo.par file that stores the parameterization for low x/x0

• high_parameters_path – Path to the foo.par file that stores the parameterization for high x/x0

• lowLimit – the upper limit for the low x/x0-data

• highLimit – the upper limit for the high x/x0-data

• clampToRange – forwarded to constructor

struct PolyData

Public Members

std::array<double, PolyDegree + 1> meanCoeffs

std::array<double, PolyDegree + 1> varCoeffs

std::array<double, PolyDegree + 1> weightCoeffs

class AtlasStepper

the AtlasStepper implementation for the

This is based original stepper code from the ATLAS RungeKuttaPropagator

Public Types

using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>

using Covariance = BoundSquareMatrix

using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>

using Jacobian = BoundMatrix

Public Functions

inline explicit AtlasStepper(const Config &config)

inline explicit AtlasStepper(std::shared_ptr<const MagneticFieldProvider> bField)

inline double absoluteMomentum(const State &state) const

Absolute momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Create and return the bound state at the current position.

Parameters:

• state – [in] State that will be presented as BoundState

• surface – [in] The surface to which we bind the state

• transportCov – [in] Flag steering covariance transport

• freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound

Returns:

A bound state:

• the parameters at the surface

• the stepwise jacobian towards it

• and the path length (from start - for ordering)

inline double charge(const State &state) const

Charge access.

Parameters:

state – [in] The stepping state (thread-local cache)

inline CurvilinearState curvilinearState(State &state, bool transportCov = true) const

Create and return a curvilinear state at the current position.

Parameters:

• state – [in] State that will be presented as CurvilinearState

• transportCov – [in] Flag steering covariance transport

Returns:

A curvilinear state:

• the curvilinear parameters at given position

• the stepweise jacobian towards it

• and the path length (from start - for ordering)

inline Vector3 direction(const State &state) const

inline Result<Vector3> getField(State &state, const Vector3 &pos) const

Get the field for the stepping It checks first if the access is still within the Cell, and updates the cell if necessary, then it takes the field from the cell.

Parameters:

• state – [inout] is the stepper state associated with the track the magnetic field cell is used (and potentially updated)

• pos – [in] is the field position

inline double getStepSize(const State &state, ConstrainedStep::Type stype) const

Get the step size.

Parameters:

• state – [in] The stepping state (thread-local cache)

• stype – [in] The step size type to be returned

inline void initialize(State &state, const BoundTrackParameters &par) const

inline void initialize(State &state, const BoundVector &boundParams, const std::optional<BoundMatrix> &cov, ParticleHypothesis particleHypothesis, const Surface &surface) const

inline State makeState(const Options &options) const

inline Vector3 momentum(const State &state) const

inline std::string outputStepSize(const State &state) const

Output the Step Size - single component.

Parameters:

state – [inout] The stepping state (thread-local cache)

inline double overstepLimit(const State&) const

Overstep limit.

inline const ParticleHypothesis &particleHypothesis(const State &state) const

Particle hypothesis.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Vector3 position(const State &state) const

inline bool prepareCurvilinearState(State &state) const

If necessary fill additional members needed for curvilinearState.

Compute path length derivatives in case they have not been computed yet, which is the case if no step has been executed yet.

Parameters:

state – [inout] The stepping state (thread-local cache)

Returns:

true if nothing is missing after this call, false otherwise.

inline double qOverP(const State &state) const

inline void releaseStepSize(State &state, ConstrainedStep::Type stype) const

Release the Step size.

Parameters:

• state – [inout] The stepping state (thread-local cache)

• stype – [in] The step size type to be released

inline void setIdentityJacobian(State &state) const

Method that reset the Jacobian to the Identity for when no bound state are available.

Parameters:

state – [inout] State of the stepper

inline Result<double> step(State &state, Direction propDir, const IVolumeMaterial *material) const

Perform the actual step on the state.

Note

The state contains the desired step size. It can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.

Parameters:

• state – [inout] State of the stepper

• propDir – is the direction of propagation

• material – is the optional volume material we are stepping through.

Returns:

the result of the step

inline double time(const State &state) const

Time access.

inline void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection& = FreeToBoundCorrection(false)) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Parameters:

• state – [inout] State of the stepper

• surface – [in] is the surface to which the covariance is forwarded to

inline void transportCovarianceToCurvilinear(State &state) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Parameters:

state – [inout] State of the stepper

inline void update(State &state, const FreeVector &parameters, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const

The state update method.

Parameters:

• state – [inout] The stepper state for

• parameters – [in] The new free track parameters at start

• boundParams – [in] Corresponding bound parameters

• covariance – [in] The updated covariance matrix

• surface – [in] The surface used to update the pVector

inline void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double qop, double time) const

Method to update momentum, direction and p.

Parameters:

• state – The state object

• uposition – the updated position

• udirection – the updated direction

• qop – the updated momentum value

• time – the update time

template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, Direction direction, ConstrainedStep::Type stype) const

Update step size.

It checks the status to the reference surface & updates the step size accordingly

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• oIntersection – [in] The ObjectIntersection to layer, boundary, etc

• direction – [in] The propagation direction

• stype – [in] The step size type to be set

inline void updateStepSize(State &state, double stepSize, ConstrainedStep::Type stype) const

Update step size - explicitly with a double.

Parameters:

• state – [inout] The stepping state (thread-local cache)

• stepSize – [in] The step size value

• stype – [in] The step size type to be set

inline IntersectionStatus updateSurfaceStatus(State &state, const Surface &surface, std::uint8_t index, Direction navDir, const BoundaryTolerance &boundaryTolerance, double surfaceTolerance, ConstrainedStep::Type stype, const Logger &logger = getDummyLogger()) const

Update surface status.

This method intersect the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.

Parameters:

• state – [inout] The stepping state (thread-local cache)

• surface – [in] The surface provided

• index – [in] The surface intersection index

• navDir – [in] The navigation direction

• boundaryTolerance – [in] The boundary check for this status update

• surfaceTolerance – [in] Surface tolerance used for intersection

• stype – [in] The step size type to be set

• logger – [in] Logger instance to use

struct Config

Public Members

std::shared_ptr<const MagneticFieldProvider> bField

struct Options : public Acts::StepperPlainOptions

Public Functions

inline Options(const GeometryContext &gctx, const MagneticFieldContext &mctx)

inline void setPlainOptions(const StepperPlainOptions &options)

struct State

Nested State struct for the local caching.

Public Functions

inline State(const Options &optionsIn, MagneticFieldProvider::Cache fieldCacheIn)

Constructor.

Template Parameters:

Type – of TrackParameters

Parameters:

• optionsIn – [in] The options for the stepper

• fieldCacheIn – [in] The magnetic field cache

Public Members

Covariance cov = Covariance::Zero()

const Covariance *covariance = nullptr

bool covTransport = false

bool debug = false

Debug output the string where debug messages are stored (optionally)

std::size_t debugMsgWidth = 50

std::size_t debugPfxWidth = 30

buffer & formatting for consistent output

std::string debugString = ""

Vector3 field = Vector3::Zero()

MagneticFieldProvider::Cache fieldCache

It caches the current magnetic field cell and stays (and interpolates) within as long as this is valid.

See step() code for details.

double jacobian[eBoundSize * eBoundSize] = {}

double maxPathLength = 0

bool mcondition = false

bool needgradient = false

bool newfield = true

std::size_t nSteps = 0

Total number of performed steps.

std::size_t nStepTrials = 0

Totoal number of attempted steps.

Options options

double parameters[eBoundSize] = {0., 0., 0., 0., 0., 0.}

Storage pattern of pVector /dL0 /dL1 /dPhi /the /dCM /dT X ->P[0] dX / P[ 8] P[16] P[24] P[32] P[40] P[48] Y ->P[1] dY / P[ 9] P[17] P[25] P[33] P[41] P[49] Z ->P[2] dZ / P[10] P[18] P[26] P[34] P[42] P[50] T ->P[3] dT/ P[11] P[19] P[27] P[35] P[43] P[51] Ax ->P[4] dAx/ P[12] P[20] P[28] P[36] P[44] P[52] Ay ->P[5] dAy/ P[13] P[21] P[29] P[37] P[45] P[53] Az ->P[6] dAz/ P[14] P[22] P[30] P[38] P[46] P[54] CM ->P[7] dCM/ P[15] P[23] P[31] P[39] P[47] P[55] Cache: P[56] - P[59].

ParticleHypothesis particleHypothesis = ParticleHypothesis::pion()

double pathAccumulated = 0.

double previousStepSize = 0.

std::array<double, 60> pVector = {}

bool state_ready = false

StepperStatistics statistics

The statistics of the stepper.

double step = 0

ConstrainedStep stepSize

bool useJacobian = false

template<AxisType type, AxisBoundaryType bdt = AxisBoundaryType::Open>
class Axis

calculate bin indices from a given binning structure

This class provides some basic functionality for calculating bin indices for a given binning configuration. Both equidistant as well as variable binning structures are supported.

Bin intervals are defined such that the lower bound is closed and the upper bound is open.

Template Parameters:

equidistant – flag whether binning is equidistant (true) or not (false)

class BinUtility

The BinUtility class that translated global and local position into a bins of a BinnedArray, most performant is equidistant binning without a transform, however, optionally a transform can be provided, e.g.

for binning on shifted object, the transform is usually shared with the geometric object the Array is defined on, for performance reasons, also the inverse transform is stored.

Public Functions

inline BinUtility()

Constructor for equidistant.

BinUtility(BinUtility &&sbu) = default

inline explicit BinUtility(const BinningData &bData, const Transform3 &tForm = Transform3::Identity())

Constructor from BinningData directly.

Parameters:

• bData – is the provided binning data

• tForm – is the (optional) transform

BinUtility(const BinUtility &sbu) = default

Copy constructor.

Parameters:

sbu – is the source bin utility

inline explicit BinUtility(const Transform3 &tForm)

Constructor with only a Transform3.

Parameters:

tForm – is the local to global transform

inline BinUtility(std::size_t bins, float min, float max, BinningOption opt = open, AxisDirection value = AxisDirection::AxisX, const Transform3 &tForm = Transform3::Identity())

Constructor for equidistant.

Parameters:

• bins – is the number of bins

• min – in the minimal value

• max – is the maximal value

• opt – is the binning option : open, closed

• value – is the axis direction : AxisX, AxisY, AxisZ, etc.

• tForm – is the (optional) transform

inline BinUtility(std::vector<float> &bValues, BinningOption opt = open, AxisDirection value = AxisDirection::AxisPhi, const Transform3 &tForm = Transform3::Identity())

Constructor for arbitrary.

Parameters:

• bValues – is the boundary values of the binning

• opt – is the binning option : open, closed

• value – is the axis direction : AxisX, AxisY, AxisZ, etc.

• tForm – is the (optional) transform

~BinUtility() = default

Virtual Destructor.

inline std::size_t bin(const Vector2 &lposition, std::size_t ba = 0) const

Bin from a 2D vector (following local parameters defintitions)

• no optional transform applied

• USE WITH CARE !!

You need to make sure that the local position is actually in the binning frame of the BinUtility

Parameters:

• lposition – is the local position to be set

• ba – is the bin dimension

Returns:

bin calculated from local

inline std::size_t bin(const Vector3 &position, std::size_t ba = 0) const

Bin from a 3D vector (already in binning frame)

Parameters:

• position – is the 3D position to be evaluated

• ba – is the bin dimension

Returns:

is the bin value

inline const std::vector<BinningData> &binningData() const

Return the binning data vector.

inline AxisDirection binningValue(std::size_t ba = 0) const

The type/value of the binning.

Parameters:

ba – is the binaccessor

Returns:

the binning value of the accessor entry

inline std::size_t bins() const

Return the total number of bins.

inline std::size_t bins(std::size_t ba) const

Number of bins.

Parameters:

ba – is the binaccessor

Returns:

std::size_t is the bins of the accessor entry

inline std::array<std::size_t, 3> binTriple(const Vector3 &position) const

Bin-triple fast access.

• calculate the bin triple with one transform

Parameters:

position – is the 3D position to be evaluated

Returns:

is the bin value in 3D

inline std::size_t dimensions() const

First bin maximal value.

Returns:

the dimension of the binning data

inline bool inside(const Vector3 &position) const

Check if bin is inside from Vector2 - optional transform applied.

Parameters:

position – is the global position to be evaluated

Returns:

is a boolean check

inline std::size_t max(std::size_t ba = 0) const

First bin maximal value.

Parameters:

ba – is the binaccessor

Returns:

std::size_t is the maximal bin of the accessor entry

inline int nextDirection(const Vector3 &position, const Vector3 &direction, std::size_t ba = 0) const

Return the other direction for fast interlinking.

Parameters:

• position – is the global position for the next search

• direction – is the global position for the next search

• ba – is the bin accessor

Returns:

the next bin

inline BinUtility &operator+=(const BinUtility &gbu)

Operator+= to make multidimensional BinUtility.

Parameters:

gbu – is the additional BinUtility to be chosen

BinUtility &operator=(BinUtility&&) = default

inline BinUtility &operator=(const BinUtility &sbu)

Assignment operator.

Parameters:

sbu – is the source bin utility

inline bool operator==(const BinUtility &other) const

Equality operator.

inline std::size_t serialize(const std::array<std::size_t, 3> &bin) const

Serialize the bin triple.

• this creates a simple std::size_t from a triple object

Parameters:

bin – is the bin to be serialized

inline std::ostream &toStream(std::ostream &sl, const std::string &indent = "") const

Output Method for std::ostream, to be overloaded by child classes.

Parameters:

• sl – is the ostream to be dumped into

• indent – the current indentation

Returns:

the input stream

inline std::string toString(const std::string &indent = "") const

Output into a string.

Parameters:

indent – the current indentation

Returns:

a string with the stream information

inline const Transform3 &transform() const

Transform applied to global positions before lookup.

Returns:

Shared pointer to transform

Friends

inline friend std::ostream &operator<<(std::ostream &sl, const BinUtility &bgen)

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

class BinnedSurfaceMaterial : public Acts::ISurfaceMaterial

It extends the ISurfaceMaterial base class and is an array pf MaterialSlab.

This is not memory optimised as every bin holds one material property object.

Public Functions

BinnedSurfaceMaterial() = delete

Default Constructor - deleted.

BinnedSurfaceMaterial(BinnedSurfaceMaterial &&bsm) = default

Copy Move Constructor.

Parameters:

bsm – is the source object to be copied

BinnedSurfaceMaterial(const BinnedSurfaceMaterial &bsm) = default

Copy Constructor.

Parameters:

bsm – is the source object to be copied

BinnedSurfaceMaterial(const BinUtility &binUtility, MaterialSlabMatrix fullProperties, double splitFactor = 0., MappingType mappingType = MappingType::Default)

Explicit constructor with only full MaterialSlab, for two-dimensional binning.

The split factors:

• 1. : oppositePre

• 0. : alongPre ===> 1 Dimensional array

Parameters:

• binUtility – defines the binning structure on the surface (copied)

• fullProperties – is the vector of properties as recorded (moved)

• splitFactor – is the pre/post splitting directive

• mappingType – is the type of surface mapping associated to the surface

BinnedSurfaceMaterial(const BinUtility &binUtility, MaterialSlabVector fullProperties, double splitFactor = 0., MappingType mappingType = MappingType::Default)

Explicit constructor with only full MaterialSlab, for one-dimensional binning.

The split factors:

• 1. : oppositePre

• 0. : alongPre ===> 1 Dimensional array

Parameters:

• binUtility – defines the binning structure on the surface (copied)

• fullProperties – is the vector of properties as recorded (moved)

• splitFactor – is the pre/post splitting directive

• mappingType – is the type of surface mapping associated to the surface

~BinnedSurfaceMaterial() override = default

Destructor.

inline const BinUtility &binUtility() const

Return the BinUtility.

inline const MaterialSlabMatrix &fullMaterial() const

Retrieve the entire material slab matrix.

virtual const MaterialSlab &materialSlab(const Vector2 &lp) const final

Return method for full material description of the Surface.

• from local coordinate on the surface

Parameters:

lp – is the local position used for the (eventual) lookup

Returns:

const MaterialSlab

virtual const MaterialSlab &materialSlab(const Vector3 &gp) const final

Return method for full material description of the Surface.

• from the global coordinates

Parameters:

gp – is the global position used for the (eventual) lookup

Returns:

const MaterialSlab

BinnedSurfaceMaterial &operator=(BinnedSurfaceMaterial &&bsm) = default

Assignment Move operator.

BinnedSurfaceMaterial &operator=(const BinnedSurfaceMaterial &bsm) = default

Assignment operator.

virtual BinnedSurfaceMaterial &scale(double factor) final

Scale operation.

Parameters:

factor – is the scale factor for the full material

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

Output Method for std::ostream, to be overloaded by child classes.

class BinningData

This class holds all the data necessary for the bin calculation.

phi has a very particular behaviour:

• there’s the change around +/- PI

• it can be multiplicative or additive multiplicative : each major bin has the same sub structure i.e. first binnning

structure is equidistant additive : sub structure replaces one bin (and one bin only)

Public Functions

BinningData() = default

inline BinningData(AxisDirection bValue, float bMin, float bMax)

Constructor for 0D binning.

Parameters:

• bValue – is the axis direction AxisX, AxisY, etc.

• bMin – is the minimum value

• bMax – is the maximum value

inline BinningData(BinningOption bOption, AxisDirection bValue, const std::vector<float> &bBoundaries, std::unique_ptr<const BinningData> sBinData = nullptr)

Constructor for non-equidistant binning.

Parameters:

• bOption – is the binning option : open / closed

• bValue – is the axis direction : AxisX, AxisY, etc.

• bBoundaries – are the bin boundaries

• sBinData – is (optional) sub structure

inline BinningData(BinningOption bOption, AxisDirection bValue, std::size_t bBins, float bMin, float bMax, std::unique_ptr<const BinningData> sBinData = nullptr, bool sBinAdditive = false)

Constructor for equidistant binning and optional sub structure can be multiplicative or additive.

Parameters:

• bOption – is the binning option : open, closed

• bValue – is the axis direction: Axis, AxisY, etc.

• bBins – is number of equidistant bins

• bMin – is the minimum value

• bMax – is the maximum value

• sBinData – is (optional) sub structure

• sBinAdditive – is the prescription for the sub structure

inline BinningData(const BinningData &bdata)

Copy constructor.

Parameters:

bdata – is the source object

~BinningData() = default

inline std::size_t bins() const

Return the number of bins - including sub bins.

inline const std::vector<float> &boundaries() const

Return the boundaries - including sub boundaries.

Returns:

vector of floats indicating the boundary values

inline float center(std::size_t bin) const

Get the center value of a bin.

Parameters:

bin – is the bin for which the center value is requested

Returns:

float value according to the bin center

inline float centerValue(std::size_t bin) const

access to the center value this uses the bin boundary vector, it also works with sub structure

Parameters:

bin – is the bin for which the value is requested, if bin > nbins it is set to max

Returns:

the center value of the bin is given

inline bool inside(const Vector2 &lposition) const

Check if bin is inside from Vector2.

Parameters:

lposition – is the search position in global coordinated

Returns:

boolean if this is inside() method is true

inline bool inside(const Vector3 &position) const

Check if bin is inside from Vector3.

Parameters:

position – is the search position in global coordinated

Returns:

boolean if this is inside() method is true

inline int nextDirection(const Vector3 &position, const Vector3 &dir) const

Layer next direction is needed.

Parameters:

• position – is the start search position

• dir – is the direction

Returns:

integer that indicates which direction to move

inline BinningData &operator=(const BinningData &bdata)

Assignment operator.

Parameters:

bdata – is the source object

inline bool operator==(const BinningData &bData) const

Equality operator.

Parameters:

bData – is the binning data to be checked against

Returns:

a boolean indicating if they are the same

inline std::size_t search(float value) const

Generic search - forwards to correct function pointer.

Parameters:

value – is the searchvalue as float

Returns:

bin according tot this

inline std::size_t searchGlobal(const Vector3 &position) const

Generic search from a 3D position &#8212; corresponds to global coordinate schema.

Parameters:

position – is the search position in global coordinated

Returns:

bin according tot this

inline std::size_t searchLocal(const Vector2 &lposition) const

Generic search from a 2D position &#8212; corresponds to local coordinate schema.

Parameters:

lposition – is the search position in local coordinated

Returns:

bin according tot this

inline std::size_t searchWithSubStructure(float value) const

Generic search with sub structure.

• forwards to correct function pointer

Parameters:

value – is the searchvalue as float

Returns:

bin according tot this

inline std::string toString(const std::string &indent = "") const

String screen output method.

Parameters:

indent – the current indentation

Returns:

a string containing the screen information

inline float value(const Vector2 &lposition) const

Take the right float value.

Parameters:

lposition – assumes the correct local position expression

Returns:

float value according to the binning setup

inline float value(const Vector3 &position) const

Take the right float value.

Parameters:

position – is the global position

Returns:

float value according to the binning setup

inline float width(std::size_t bin) const

Get the width of a bin.

Parameters:

bin – is the bin for which the width is requested

Returns:

float value of width

Public Members

AxisDirection binvalue = {}

axis direction: AxisX, AxisY, AxisZ, …

float max = {}

maximum value

float min = {}

minimum value

BinningOption option = {}

binning option: open, closed

float step = {}

binning step

bool subBinningAdditive = {}

sub structure: additive or multipicative

std::unique_ptr<const BinningData> subBinningData

sub structure: describe some sub binning

BinningType type = {}

binning type: equidistant, arbitrary

bool zdim = {}

zero dimensional binning : direct access

class BoundaryTolerance

Variant-like type to capture different types of boundary tolerances.

Since our track hypothesis comes with uncertainties, we sometimes need to check if the track is not just within the boundary of the surface but also within a certain tolerance. This class captures different parameterizations of such tolerances. The surface class will then use these tolerances to check if a ray is within the boundary+tolerance of the surface.

Different types of boundary tolerances implemented:

• Infinite: Infinite tolerance i.e. no boundary check will be performed.

• None: No tolerance i.e. exact boundary check will be performed.

• AbsoluteBound: Absolute tolerance in bound coordinates. The tolerance is defined as a pair of absolute values for the bound coordinates. Only if both coordinates are within the tolerance, the boundary check is considered as passed.

• AbsoluteCartesian: Absolute tolerance in Cartesian coordinates. The tolerance is defined as a pair of absolute values for the Cartesian coordinates. The transformation to Cartesian coordinates can be done via the Jacobian for small distances. Only if both coordinates are within the tolerance, the boundary check is considered as passed.

• AbsoluteEuclidean: Absolute tolerance in Euclidean distance. The tolerance is defined as a single absolute value for the Euclidean distance. The Euclidean distance can be calculated via the local bound Jacobian and the bound coordinate residual. If the distance is within the tolerance, the boundary check is considered as passed.

• Chi2Bound: Chi2 tolerance in bound coordinates. The tolerance is defined as a maximum chi2 value and a weight matrix, which is the inverse of the bound covariance matrix. The chi2 value is calculated from the bound coordinates residual and the weight matrix. If the chi2 value is below the maximum chi2 value, the boundary check is considered as passed.

The bound coordinates residual is defined as the difference between the point checked and the closest point on the boundary. The Jacobian is the derivative of the bound coordinates with respect to the Cartesian coordinates.

Public Types

enum class ToleranceMode

Values:

enumerator Extend

enumerator None

enumerator Shrink

Public Functions

AbsoluteBoundParams asAbsoluteBound(bool isCartesian = false) const

Get the tolerance as absolute bound.

std::optional<AbsoluteBoundParams> asAbsoluteBoundOpt(bool isCartesian = false) const

Get the tolerance as absolute bound if possible.

const AbsoluteCartesianParams &asAbsoluteCartesian() const

Get the tolerance as absolute Cartesian.

const AbsoluteEuclideanParams &asAbsoluteEuclidean() const

Get the tolerance as absolute Euclidean.

const Chi2BoundParams &asChi2Bound() const

Get the tolerance as chi2 bound.

SquareMatrix2 getMetric(const std::optional<SquareMatrix2> &jacobian) const

Get the metric for the tolerance.

bool hasAbsoluteBound(bool isCartesian = false) const

Check if the tolerance is absolute with bound coordinates.

bool hasAbsoluteCartesian() const

Check if the tolerance is absolute with Cartesian coordinates.

bool hasAbsoluteEuclidean() const

Check if the tolerance is absolute with Euclidean distance.

bool hasChi2Bound() const

Check if the tolerance is chi2 with bound coordinates.

bool hasMetric(bool hasJacobian) const

Check if there is a metric assigned with this tolerance.

bool isInfinite() const

Check if the tolerance is infinite.

bool isNone() const

Check if the is no tolerance.

bool isTolerated(const Vector2 &distance, const std::optional<SquareMatrix2> &jacobianOpt) const

Check if the distance is tolerated.

ToleranceMode toleranceMode() const

Check if any tolerance is set.

Public Static Functions

static inline auto AbsoluteBound(double tolerance0, double tolerance1)

Absolute tolerance in bound coordinates.

static inline auto AbsoluteCartesian(double tolerance0, double tolerance1)

Absolute tolerance in Cartesian coordinates.

static inline auto AbsoluteEuclidean(double tolerance)

Absolute tolerance in Euclidean distance.

static inline auto Chi2Bound(const SquareMatrix2 &weight, double maxChi2)

Chi2 tolerance in bound coordinates.

static inline auto Infinite()

Infinite tolerance i.e. no boundary check.

static inline auto None()

No tolerance i.e. exact boundary check.

struct AbsoluteBoundParams

Public Functions

AbsoluteBoundParams() = default

inline AbsoluteBoundParams(double tolerance0_, double tolerance1_)

Public Members

double tolerance0 = {}

double tolerance1 = {}

struct AbsoluteCartesianParams

Public Functions

AbsoluteCartesianParams() = default

inline AbsoluteCartesianParams(double tolerance0_, double tolerance1_)

Public Members

double tolerance0 = {}

double tolerance1 = {}

struct AbsoluteEuclideanParams

Public Functions

AbsoluteEuclideanParams() = default

inline explicit AbsoluteEuclideanParams(double tolerance_)

Public Members

double tolerance = {}

struct Chi2BoundParams

Public Functions

Chi2BoundParams() = default

inline Chi2BoundParams(const SquareMatrix2 &weight_, double maxChi2_)

Public Members

double maxChi2 = {}

SquareMatrix2 weight = SquareMatrix2::Identity()

struct InfiniteParams

struct NoneParams

class CalibrationContext : public ContextType

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

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

template<typename propagator_t, typename track_container_t>
class CombinatorialKalmanFilter

Combinatorial Kalman filter to find tracks.

The CombinatorialKalmanFilter contains an Actor and a Sequencer sub-class. The Sequencer has to be part of the Navigator of the Propagator in order to initialize and provide the measurement surfaces.

The Actor is part of the Propagation call and does the Kalman update. Updater and Calibrator are given to the Actor for further use:

• The Updater is the implemented kalman updater formalism, it runs via a visitor pattern through the measurements.

Measurements are not required to be ordered for the CombinatorialKalmanFilter, measurement ordering needs to be figured out by the navigation of the propagator.

The void components are provided mainly for unit testing.

Template Parameters:

propagator_t – Type of the propagator

Public Functions

CombinatorialKalmanFilter() = delete

Default constructor is deleted.

inline CombinatorialKalmanFilter(propagator_t pPropagator, std::unique_ptr<const Logger> _logger = getDefaultLogger("CKF", Logging::INFO))

Constructor from arguments.

template<typename start_parameters_t, typename parameters_t = BoundTrackParameters>
inline auto findTracks(const start_parameters_t &initialParameters, const CombinatorialKalmanFilterOptions<track_container_t> &tfOptions, track_container_t &trackContainer) const -> Result<std::vector<typename std::decay_t<decltype(trackContainer)>::TrackProxy>>

Combinatorial Kalman Filter implementation, calls the Kalman filter.

Note

The input measurements are given in the form of SourceLinks. It’s calibrator_t's job to turn them into calibrated measurements used in the track finding.

Template Parameters:

• start_parameters_t – Type of the initial parameters

• parameters_t – Type of parameters used for local parameters

Parameters:

• initialParameters – The initial track parameters

• tfOptions – CombinatorialKalmanFilterOptions steering the track finding

• trackContainer – Track container in which to store the results

Returns:

a container of track finding result for all the initial track parameters

template<typename start_parameters_t, typename parameters_t = BoundTrackParameters>
inline auto findTracks(const start_parameters_t &initialParameters, const CombinatorialKalmanFilterOptions<track_container_t> &tfOptions, track_container_t &trackContainer, typename track_container_t::TrackProxy rootBranch) const -> Result<std::vector<typename std::decay_t<decltype(trackContainer)>::TrackProxy>>

Combinatorial Kalman Filter implementation, calls the Kalman filter.

Note

The input measurements are given in the form of SourceLinks. It’s calibrator_t's job to turn them into calibrated measurements used in the track finding.

Template Parameters:

• start_parameters_t – Type of the initial parameters

• parameters_t – Type of parameters used for local parameters

Parameters:

• initialParameters – The initial track parameters

• tfOptions – CombinatorialKalmanFilterOptions steering the track finding

• trackContainer – Track container in which to store the results

• rootBranch – The track to be used as the root branch

Returns:

a container of track finding result for all the initial track parameters

class ConeBounds : public Acts::SurfaceBounds

Bounds for a conical surface, the opening angle is stored in \( \tan(\alpha) \) and always positively defined.

The cone can open to both sides, steered by \( z_min \) and \( z_max \).

Public Types

enum BoundValues

Values:

enumerator eAlpha

enumerator eMinZ

enumerator eMaxZ

enumerator eHalfPhiSector

enumerator eAveragePhi

enumerator eSize

Public Functions

ConeBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from parameters array.

Parameters:

values – The parameter array

ConeBounds(double alpha, bool symm, double halfphi = std::numbers::pi, double avphi = 0.) noexcept(false)

Constructor - open cone with alpha, by default a full cone but optionally can make a conical section.

Parameters:

• alpha – is the opening angle of the cone

• symm – is the boolean indicating if the cone is symmetric in +/- z

• halfphi – is the half opening angle (default is pi)

• avphi – is the phi value around which the bounds are opened (default=0)

ConeBounds(double alpha, double minz, double maxz, double halfphi = std::numbers::pi, double avphi = 0.) noexcept(false)

Constructor - open cone with alpha, minz and maxz, by default a full cone but can optionally make it a conical section.

Parameters:

• alpha – is the opening angle of the cone

• minz – cone expanding from minimal z

• maxz – cone expanding to maximal z

• halfphi – is the half opening angle (default is pi)

• avphi – is the phi value around which the bounds are opened (default=0)

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 BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None()) const final

inside method for local position

Parameters:

• lposition – is the local position to be checked

• boundaryTolerance – is the boundary check directive

Returns:

is a boolean indicating if the position is inside

inline double r(double z) const

Return the radius at a specific z values.

Parameters:

z – is the z value for which r is requested

Returns:

is the r value associated with z

inline double tanAlpha() const

Return tangent of alpha (pre-computed)

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

Output Method for std::ostream.

Parameters:

sl – is the ostrea into which the dump is done

Returns:

is the input object

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class ConeLayer : public virtual Acts::ConeSurface, public Acts::Layer

Class to describe a conical detector layer for tracking, it inhertis from both, Layer base class and ConeSurface class.

Public Functions

ConeLayer() = delete

ConeLayer(const ConeLayer &cla) = delete

~ConeLayer() override = default

ConeLayer &operator=(const ConeLayer&) = delete

virtual const ConeSurface &surfaceRepresentation() const override

Transforms the layer into a Surface representation for extrapolation.

virtual ConeSurface &surfaceRepresentation() override

Public Static Functions

static inline MutableLayerPtr create(const Transform3 &transform, std::shared_ptr<const ConeBounds> cbounds, std::unique_ptr<SurfaceArray> surfaceArray, double thickness = 0., std::unique_ptr<ApproachDescriptor> ad = nullptr, LayerType laytyp = Acts::active)

Factory for shared layer.

Parameters:

• transform – is the 3D transform that positions the layer in 3D frame

• cbounds – is the conical bound description

• surfaceArray – is the array of sensitive surfaces

• thickness – is the layer thickness along the normal axis

• ad – is the approach descriptor for navigation towards the layer

• laytyp – is the layer type

Returns:

is a shared pointer to a layer

class ConeSurface : public Acts::RegularSurface

Class for a conical surface in the Tracking geometry.

It inherits from Surface.

The ConeSurface is special since no corresponding Track parameters exist since they’re numerical instable at the tip of the cone. Propagations to a cone surface will be returned in curvilinear coordinates.

Subclassed by Acts::ConeLayer

Public Functions

virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. the alignment parameters

virtual const ConeBounds &bounds() const final

This method returns the ConeBounds by reference.

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Convert a global position to a local one this is the most generic interface, which is implemented by all surfaces.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• direction – is the direction of the local position (ignored for RegularSurface)

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const final

Global to local transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be transformed

• tolerance – optional tolerance within which a point is considered valid on surface

Returns:

a Result<Vector2> which can be !ok() if the operation fails

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const = 0

Convert a global position to a local one.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const final

Straight line intersection schema from position/direction.

If possible returns both solutions for the cylinder

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position to start from

• direction – The direction at start

• boundaryTolerance – the Boundary Check

• tolerance – the tolerance used for the intersection

Returns:

SurfaceMultiIntersection object (contains intersection & surface)

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const final

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position to be transformed

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

This is the most generic interface, which is implemented by all surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction (ignored for RegularSurface)

Returns:

The global position by value

virtual std::string name() const override

Return properly formatted class name for screen output.

virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final

Return method for surface normal information.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position at normal vector request

Returns:

Vector3 normal vector in global frame

Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Calculate the normal vector of the surface This overload requires an on-surface local position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position where the normal vector is constructed

Returns:

normal vector by value

Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const final

Calculate the normal vector of the surface This overload is fully generic, fulfills the Surface interface and accepts a global position and a direction.

For RegularSurface this is equivalent to the normal overload, ignoring the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – is the global position where the normal vector is constructed

• direction – is the direction of the normal vector (ignored for RegularSurface)

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final

Return method for surface normal information.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position as normal vector base

Returns:

Vector3 normal vector in global frame

Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the normal vector of the surface This overload accepts a global position.

Parameters:

• position – is the global position where the normal vector is constructed

• gctx – The current geometry context object, e.g. alignment

Returns:

normal vector by value

ConeSurface &operator=(const ConeSurface &other)

Assignment operator.

Parameters:

other – is the source surface for the assignment

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

The pathCorrection for derived classes with thickness.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global potion at the correction point

• direction – is the momentum direction at the correction point

Returns:

is the path correction due to incident angle

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments = 2u) const override

Return a Polyhedron for the surfaces.

Note

The phi extrema points at (-pi, -1/2 pi, 0, 1/2 pi) that fall within the surface will be inserted to guarantee an appropriate extent measurement in x and y

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – Number of segments used to approximate a quarter

Returns:

A list of vertices and a face/facett description of it

virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface.

• the default implementation is the RotationMatrix3 of the transform

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position where the measurement frame is constructed

• direction – is the momentum direction used for the measurement frame construction

Returns:

matrix that indicates the measurement frame

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

The binning position method - is overloaded for r-type binning.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – defines the direction of binning applied in the global frame

Returns:

The return type is a vector for positioning in the global frame

virtual Vector3 rotSymmetryAxis(const GeometryContext &gctx) const

Parameters:

gctx – The current geometry context object, e.g. alignment

virtual SurfaceType type() const override

Return the surface type.

class ConeVolumeBounds : public Acts::VolumeBounds

Volume bound class for describing conical volumes either with cylindrical inlay or outer boundary, it also allows for a sectoral description.

Public Types

enum BoundValues

for readability

Values:

enumerator eInnerAlpha

enumerator eInnerOffsetZ

enumerator eOuterAlpha

enumerator eOuterOffsetZ

enumerator eHalfLengthZ

enumerator eAveragePhi

enumerator eHalfPhiSector

enumerator eSize

Public Functions

ConeVolumeBounds() = delete

ConeVolumeBounds(const ConeVolumeBounds &cobo) = default

inline ConeVolumeBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from a fixed size array.

Parameters:

values – The bound values

ConeVolumeBounds(double cylinderR, double alpha, double offsetZ, double halflengthZ, double averagePhi, double halfPhiSector) noexcept(false)

Constructor - for general cylidner-cone setups.

Note

depending on cylinderR > coneR it is constructing a cone with cylindrical cutout or a cylinder with conical cutout

Parameters:

• cylinderR – The inner radius of the cylinder

• alpha – The opening angle of the cone (0 if no cone)

• offsetZ – The tip z position in of the cone, w.r.t center

• halflengthZ – The minimum z value of the inner and outer cones

• averagePhi – The phi orientation of the sector (defaulted to 0)

• halfPhiSector – The opening angle phi sector

ConeVolumeBounds(double innerAlpha, double innerOffsetZ, double outerAlpha, double outerOffsetZ, double halflengthZ, double averagePhi, double halfPhiSector) noexcept(false)

Constructor - for general cone-cone setups.

Parameters:

• innerAlpha – The opening angle of the inner cone (0 if no cone)

• innerOffsetZ – The tip z position in of the inner cone, w.r.t center

• outerAlpha – The opening angle of the outer cone (0 if no cone)

• outerOffsetZ – The tip z position in of the outer cone, w.r.t center

• halflengthZ – The minimum z value of the inner and outer cones

• averagePhi – The phi orientation of the sector

• halfPhiSector – The opening angle phi sector

~ConeVolumeBounds() override = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

double innerRmax() const

double innerRmin() const

double innerTanAlpha() const

virtual bool inside(const Vector3 &pos, double tol = 0.) const final

This method checks if position in the 3D volume frame is inside the cylinder.

Parameters:

• pos – is the position in volume frame to be checked

• tol – is the absolute tolerance to be applied

ConeVolumeBounds &operator=(const ConeVolumeBounds &cobo) = default

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const final

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

double outerRmax() const

double outerRmin() const

double outerTanAlpha() const

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

Output Method for std::ostream.

Parameters:

os – is ostream operator to be dumped into

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class ConstantBField : public Acts::MagneticFieldProvider

This class implements a simple constant magnetic field.

The magnetic field value has to be set at creation time, but can be updated later on.

Public Functions

inline explicit ConstantBField(Vector3 B)

Construct constant magnetic field from field vector.

Parameters:

B – [in] magnetic field vector in global coordinate system

inline Vector3 getField() const

Get the B field at a position.

inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override

Retrieve magnetic field value at a given location.

Requires a cache object created through makeCache().

Note

The position is ignored and only kept as argument to provide a consistent interface with other magnetic field services.

Parameters:

• position – [in] global 3D position for the lookup

• cache – [inout] Field provider specific cache object

Returns:

magnetic field vector at given position

inline bool isInside(const Vector3&) const

check whether given 3D position is inside look-up domain

Returns:

Always true for constant magnetic field

inline virtual Acts::MagneticFieldProvider::Cache makeCache(const Acts::MagneticFieldContext &mctx) const override

Make an opaque cache for the magnetic field.

Instructs the specific implementation to generate a Cache instance for magnetic field lookup.

Parameters:

mctx – The magnetic field context to generate cache for

Returns:

Cache The opaque cache object

inline void setField(const Vector3 &B)

update magnetic field vector

Parameters:

B – [in] magnetic field vector in global coordinate system

struct Cache

Public Functions

inline Cache(const MagneticFieldContext&)

constructor with context

class ConstrainedStep

A constrained step class for the steppers.

This class is symmetrical for forward and backward propagation. The sign of the propagation direction should not enter here but rather be applied the step is actually taken.

As simple as this class looks it hides a few very important details:

• Overstepping handling. The step size sign will flip if we happened to pass our target.

• Convergence handling. Smaller and smaller step sizes have to be used in order to converge on a target.

Because of the points mentioned above, the update function will always prefer negative step sizes. A side effect of this is that we will propagate in the opposite direction if the target is “behind us”.

The hierarchy is:

• Overstepping resolution / backpropagation

• Convergence

• Step into the void with std::numeric_limits<double>max()

Public Types

enum class Type : int

the types of constraints from navigator - this would be a navigation step from actor - this would be an actor condition from user - this is user given for what reason ever

Values:

enumerator Navigator

enumerator Actor

enumerator User

Public Functions

constexpr ConstrainedStep() = default

inline explicit constexpr ConstrainedStep(double v)

constructor

Parameters:

v – is the user given initial value

inline constexpr double accuracy() const

Access the accuracy value.

inline constexpr void release(Type type)

release a certain constraint value

Parameters:

type – is the constraint type to be released

inline constexpr void releaseAccuracy()

release accuracy

inline constexpr void setAccuracy(double v)

set accuracy

this will set only the accuracy, as this is the most exposed to the Propagator

Parameters:

v – is the new accuracy value

inline constexpr void setUser(double v)

set user

Parameters:

v – is the new user value

inline std::ostream &toStream(std::ostream &os) const

inline std::string toString() const

inline constexpr void update(double v, Type type)

Update the step size of a certain type.

Only navigation and target abortion step size updates may change the sign due to overstepping

Parameters:

• v – is the new value to be updated

• type – is the constraint type

inline constexpr double value() const

returns the min step size

inline constexpr double value(Type type) const

Access a specific value.

Parameters:

type – is the requested parameter type

template<int N>
class ConvexPolygonBounds : public Acts::ConvexPolygonBoundsBase

This is the actual implementation of the bounds.

It is templated on the number of vertices, but there is a specialization for dynamic number of vertices, where the underlying storage is then a vector.

Template Parameters:

N – Number of vertices

Public Types

using value_array = std::array<double, eSize>

Type that’s used to store the vertices, in this case a fixed size array.

using vertex_array = std::array<Vector2, num_vertices>

Type that’s used to store the vertices, in this case a fixed size array.

Public Functions

ConvexPolygonBounds(const std::vector<Vector2> &vertices) noexcept(false)

Constructor from a vector of vertices, to facilitate construction.

This will throw if the vector size does not match num_vertices. This will throw if the vertices do not form a convex polygon.

Parameters:

vertices – The list of vertices.

ConvexPolygonBounds(const value_array &values) noexcept(false)

Constructor from a fixed size array of parameters This will throw if the vertices do not form a convex polygon.

Parameters:

values – The values to build up the vertices

ConvexPolygonBounds(const vertex_array &vertices) noexcept(false)

Constructor from a fixed size array of vertices.

This will throw if the vertices do not form a convex polygon.

Parameters:

vertices – The vertices

virtual const RectangleBounds &boundingBox() const final

Return a rectangle bounds object that encloses this polygon.

Returns:

The rectangular bounds

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) const final

Return whether a local 2D point lies inside of the bounds defined by this object.

Parameters:

• lposition – The local position to check

• boundaryTolerance – The BoundaryTolerance object handling tolerances.

Returns:

Whether the points is inside

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

virtual std::vector<Vector2> vertices(unsigned int ignoredSegments = 0u) const final

Return the vertices.

Note

the number of segments is ignored in this representation

Parameters:

ignoredSegments – the number of segments used to approximate and eventually curved line

Returns:

vector for vertices in 2D

Public Static Attributes

static constexpr std::size_t eSize = 2 * N

Expose number of parameters as a template parameter.

static constexpr std::size_t num_vertices = N

Expose number of vertices given as template parameter.

class ConvexPolygonBoundsBase : public Acts::PlanarBounds

base class for convex polygon bounds

This class serves as a base class for the actual bounds class. The only deriving type is the templated ConvexPolygonBounds.

Subclassed by Acts::ConvexPolygonBounds< N >, Acts::ConvexPolygonBounds< PolygonDynamic >

Public Functions

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

Output Method for std::ostream.

Parameters:

sl – is the ostream to be written into

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class CuboidVolumeBounds : public Acts::VolumeBounds

Bounds for a cubical Volume, the orientedSurfaces(…) method creates a vector of 6 surfaces:

BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Rectangular Acts::PlaneSurface, parallel to \( xy \) plane at negative \( z \)

• positiveFaceXY [1] : Rectangular Acts::PlaneSurface, parallel to \( xy \) plane at positive \( z \)

• negativeFaceXY [2] : Rectangular Acts::PlaneSurface, attached to \( yz \) plane at negative \( x \)

• positiveFaceXY [3] : Rectangular Acts::PlaneSurface, attached to \( yz \) plane at negative \( x \)

• negativeFaceXY [4] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at negative \( y \)

• positiveFaceXY [5] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at positive \( y \)

Public Types

enum BoundValues

for streaming and access

Values:

enumerator eHalfLengthX

enumerator eHalfLengthY

enumerator eHalfLengthZ

enumerator eSize

Public Functions

CuboidVolumeBounds() = delete

CuboidVolumeBounds(const CuboidVolumeBounds &bobo) = default

Copy Constructor.

Parameters:

bobo – is the source volume bounds to be copied

CuboidVolumeBounds(const std::array<double, eSize> &values)

Constructor - from a fixed size array.

Parameters:

values – iw the bound values

CuboidVolumeBounds(double halex, double haley, double halez) noexcept(false)

Constructor - the box boundaries.

Parameters:

• halex – is the half length of the cube in x

• haley – is the half length of the cube in y

• halez – is the half length of the cube in z

CuboidVolumeBounds(std::initializer_list<std::pair<BoundValues, double>> keyValues)

~CuboidVolumeBounds() override = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline virtual std::vector<AxisDirection> canonicalAxes() const override

Get the canonical binning direction, i.e.

the binning directions for that fully describe the shape’s extent

Returns:

vector of canonical binning values

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector3 &pos, double tol = 0.) const override

This method checks if position in the 3D volume frame is inside the cylinder.

Parameters:

• pos – is the position in volume frame to be checked

• tol – is the absolute tolerance to be applied

CuboidVolumeBounds &operator=(const CuboidVolumeBounds &bobo) = default

Assignment operator.

Parameters:

bobo – is the source volume bounds to be assigned

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

virtual double referenceBorder(AxisDirection aDir) const final

Binning borders in double.

Parameters:

aDir – is the axis direction for which the reference border is requested

Returns:

float offset to be used for the binning

void set(BoundValues bValue, double value)

Set a bound value.

Parameters:

• bValue – the bound value identifier

• value – the value to be set

void set(std::initializer_list<std::pair<BoundValues, double>> keyValues)

Set a range of bound values.

Parameters:

keyValues – the initializer list of key value pairs

virtual std::ostream &toStream(std::ostream &os) const override

Output Method for std::ostream.

Parameters:

os – is ostream operator to be dumped into

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

Public Static Functions

static BoundValues fromAxisDirection(AxisDirection direction)

Convert axis direction to a corresponding bound value in local coordinate convention.

Parameters:

direction – the axis direction to convert

class CuboidVolumeStack : public Acts::Volume

This class implements a x-.

y-. z-aligned stack of cuboid volumes with synchronized bounds. Externally, it presents as a single volume. On construction, the input volumes are modified so that they are connected in x, y, z and have synchronized bounds. The way this is done can be configured using an attachment and a resize strategy. Depending on the configuration, the input volumes are either extended or gap volumes are created.

Note

The size adjustment convention is that volumes are never shrunk

Public Functions

CuboidVolumeStack(std::vector<Volume*> &volumes, AxisDirection direction, VolumeAttachmentStrategy strategy = VolumeAttachmentStrategy::Midpoint, VolumeResizeStrategy resizeStrategy = VolumeResizeStrategy::Expand, const Logger &logger = Acts::getDummyLogger())

Constructor from a vector of volumes and direction.

Note

resizeStrategy only affects resizing along direction. Resizing in the other direction is always delegated to the child volumes, which might in turn be CuboidVolumeStack

Note

Preconditions are checked on construction

Parameters:

• volumes – is the vector of volumes

• direction – is the axis direction

• strategy – is the attachment strategy

• resizeStrategy – is the resize strategy

• logger – is the logger

Pre:

The volumes need to have a common coordinate system relative to direction. I.e. they need to be aligned in z and cannot have a rotation in x or y.

Pre:

The volumes all need to have CuboidVolumeBounds

CuboidVolumeStack(std::vector<Volume*> &volumes, const Vector3 &direction, VolumeAttachmentStrategy strategy = VolumeAttachmentStrategy::Midpoint, VolumeResizeStrategy resizeStrategy = VolumeResizeStrategy::Expand, const Logger &logger = Acts::getDummyLogger())

Constructor from a vector of volumes and direction.

Note

resizeStrategy only affects resizing along direction. Resizing in the other direction is always delegated to the child volumes, which might in turn be CuboidVolumeStack

Note

Preconditions are checked on construction

Parameters:

• volumes – is the vector of volumes

• direction – is the vector specifying the global direction

• strategy – is the attachment strategy

• resizeStrategy – is the resize strategy

• logger – is the logger

Pre:

The volumes need to have a common coordinate system relative to direction. I.e. they need to be aligned in z and cannot have a rotation in x or y.

Pre:

The volumes all need to have CuboidVolumeBounds

const std::vector<std::shared_ptr<Volume>> &gaps() const

Access the gap volume that were created during attachment or resizing.

Returns:

the vector of gap volumes

virtual void update(std::shared_ptr<VolumeBounds> volbounds, std::optional<Transform3> transform = std::nullopt, const Logger &logger = getDummyLogger()) override

Update the volume bounds and transform.

This will update the bounds of all volumes in the stack to accommodate the new bounds and optionally create gap volumes according to the resize strategy set during construction.

Parameters:

• volbounds – is the new bounds

• transform – is the new transform

• logger – is the logger

Pre:

The volume bounds need to be of type CuboidVolumeBounds.

Public Static Functions

static std::size_t axisToIndex(AxisDirection direction)

Convert axis direction to an array index according to stack convention.

For example, AxisX –> 0

Parameters:

direction – is the axis direction to convert

static std::pair<AxisDirection, AxisDirection> getOrthogonalAxes(AxisDirection direction)

Get axis directions orthogonal to the given one according to stack convention.

For example AxisX –> <AxisY, AxisZ>

Parameters:

direction – is the axis direction to find the orthogonal for

class CutoutCylinderVolumeBounds : public Acts::VolumeBounds

Class which implements a cutout cylinder.

This shape is basically a cylinder, with another, smaller cylinder subtracted from the center. ——————&#8212; rmax | | | |——&#8212;| | rmed | | | | —&#8212; —&#8212; rmin &#8212; hlZc &#8212; ——&#8212; hlZ —-&#8212;

Public Types

enum BoundValues

for streaming and access

Values:

enumerator eMinR

enumerator eMedR

enumerator eMaxR

enumerator eHalfLengthZ

enumerator eHalfLengthZcutout

enumerator eSize

Public Functions

inline CutoutCylinderVolumeBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from a fixed size array.

Parameters:

values – The bound values

inline CutoutCylinderVolumeBounds(double rmin, double rmed, double rmax, double hlZ, double hlZc) noexcept(false)

Constructor from defining parameters.

Parameters:

• rmin – Minimum radius at the “choke points”

• rmed – The medium radius (outer radius of the cutout)

• rmax – The outer radius of the overall shape

• hlZ – The longer halflength of the shape

• hlZc – The cutout halflength of the shape

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline virtual std::vector<AxisDirection> canonicalAxes() const override

Get the canonical binning direction, i.e.

the axis values that fully describe the shape’s extent

Returns:

vector of canonical binning values

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector3 &gpos, double tol = 0) const override

Inside method to test whether a point is inside the shape.

Parameters:

• gpos – The point to test

• tol – The tolerance to test with

Returns:

Whether the point is inside or not.

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

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

Write information about this instance to an outstream.

Parameters:

sl – The outstream

Returns:

The outstream

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class CylinderBounds : public Acts::SurfaceBounds

Bounds for a cylindrical Surface.

These bounds may be used for a CylinderSurface In case of bounds for a StraightLineSurface the radius determines the radius within a localPosition is regarded as inside bounds.

CylinderBounds also enhance the possibility of a cylinder segment with an opening angle \( 2\cdot\phi_{half}\) around an average \( \phi \) angle \( \phi_{ave} \).

CylinderBounds also supports beveled sides defined by an angle. Different angles can be defined on both sides of the cylinder. A positive angle is defined as “extruding” from the defined Zlength, while a negative angle is “intruding” on the Zlength.

• - - +

  \ | / \ | / \ | / \ | / |/______________|/ 2 * ZhalfLength

Public Types

enum BoundValues

Values:

enumerator eR

enumerator eHalfLengthZ

enumerator eHalfPhiSector

enumerator eAveragePhi

enumerator eBevelMinZ

enumerator eBevelMaxZ

enumerator eSize

Public Functions

inline CylinderBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array.

Parameters:

values – The parameter values

inline CylinderBounds(double r, double halfZ, double halfPhi = std::numbers::pi, double avgPhi = 0., double bevelMinZ = 0., double bevelMaxZ = 0.) noexcept(false)

Constructor - full cylinder.

Parameters:

• r – The radius of the cylinder

• halfZ – The half length in z

• halfPhi – The half opening angle

• avgPhi – (optional) The phi value from which the opening angle spans

• bevelMinZ – (optional) The bevel on the negative z side

• bevelMaxZ – (optional) The bevel on the positive z sid The bevel on the positive z side

std::vector<Vector3> circleVertices(const Transform3 transform, unsigned int quarterSegments) const

Create the bow/circle vertices on either side of the cylinder.

Parameters:

• transform – is the global transform

• quarterSegments – is the number of segments to approximate a quarter of a circle. In order to symmetrize fully closed and sectoral cylinders, also in the first case the two end points are given (albeit they overlap) in -pi / pi

Returns:

a singlevector containing the vertices from one side and then from the other side consecutively

inline bool coversFullAzimuth() const

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 BoundaryTolerance &boundaryTolerance) 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)

• boundaryTolerance – boundary check tolerance directive

Returns:

boolean indicator for the success of this operation

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

Output Method for std::ostream.

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class CylinderLayer : public Acts::CylinderSurface, public Acts::Layer

Class to describe a cylindrical detector layer for tracking, it inhertis from both, Layer base class and CylinderSurface class.

Public Functions

CylinderLayer() = delete

CylinderLayer(const CylinderLayer &cla) = delete

~CylinderLayer() override = default

CylinderLayer &operator=(const CylinderLayer&) = delete

virtual const CylinderSurface &surfaceRepresentation() const override

Transforms the layer into a Surface representation This is for positioning and extrapolation.

virtual CylinderSurface &surfaceRepresentation() override

Public Static Functions

static inline std::shared_ptr<CylinderLayer> create(const Transform3 &transform, const std::shared_ptr<const CylinderBounds> &cbounds, std::unique_ptr<SurfaceArray> surfaceArray = nullptr, double thickness = 0., std::unique_ptr<ApproachDescriptor> ad = nullptr, LayerType laytyp = passive)

Factory for shared Layer pointer create a shared, fully deployed CylinderLayer.

Parameters:

• transform – is the 3D transform that places the layer in 3D space

• cbounds – are the cylindrical bounds of the layer

• surfaceArray – is the Binned Array that holds the sensitive surfaces

• thickness – is the layer thickness (along the normal)

• ad – is the approach descriptor for approaching the layer

• laytyp – is the layer type

Returns:

The return object is a shared pointer to the layer.

class CylinderSurface : public Acts::RegularSurface

Class for a CylinderSurface in the TrackingGeometry.

It inherits from Surface.

The cylinder surface has a special role in the TrackingGeometry, since it builds the surfaces of all TrackingVolumes at container level for a cylindrical tracking geometry.

Subclassed by Acts::CylinderLayer

Public Functions

virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. the alignment parameters

virtual const CylinderBounds &bounds() const final

This method returns the CylinderBounds by reference.

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Convert a global position to a local one this is the most generic interface, which is implemented by all surfaces.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• direction – is the direction of the local position (ignored for RegularSurface)

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const final

Global to local transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be transformed

• tolerance – optional tolerance within which a point is considered valid on surface

Returns:

a Result<Vector2> which can be !ok() if the operation fails

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const = 0

Convert a global position to a local one.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const final

Straight line intersection schema from position/direction.

If possible returns both solutions for the cylinder

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position to start from

• direction – The direction at start

• boundaryTolerance – the Boundary Check Tolerance

• tolerance – the tolerance used for the intersection

Returns:

SurfaceIntersection object (contains intersection & surface)

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const final

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position to be transformed

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

This is the most generic interface, which is implemented by all surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction (ignored for RegularSurface)

Returns:

The global position by value

std::pair<std::shared_ptr<CylinderSurface>, bool> mergedWith(const CylinderSurface &other, AxisDirection direction, bool externalRotation, const Logger &logger = getDummyLogger()) const

Merge two cylinder surfaces into a single one.

Note

The surfaces need to be compatible, i.e. have cylinder bounds that align, and have the same radius

Note

The returned boolean is false if this is left or counter-clockwise of other, and true if not.

Parameters:

• other – The other cylinder surface to merge with

• direction – The axis direction: either AxisZ or AxisRPhi

• externalRotation – If true, any phi rotation is done in the transform

• logger – The logger to use

Returns:

The merged cylinder surface and a boolean indicating if surfaces are reversed

virtual std::string name() const override

Return method for properly formatted output string.

virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final

Return method for surface normal information.

Note

for a Cylinder a local position is always required for the normal vector

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position for which the normal vector is requested

Returns:

normal vector at the local position by value

Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Calculate the normal vector of the surface This overload requires an on-surface local position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position where the normal vector is constructed

Returns:

normal vector by value

Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const final

Calculate the normal vector of the surface This overload is fully generic, fulfills the Surface interface and accepts a global position and a direction.

For RegularSurface this is equivalent to the normal overload, ignoring the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – is the global position where the normal vector is constructed

• direction – is the direction of the normal vector (ignored for RegularSurface)

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final

Return method for surface normal information.

Note

for a Cylinder a local position is always required for the normal vector

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position for which the normal vector is requested

Returns:

normal vector at the global position by value

Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the normal vector of the surface This overload accepts a global position.

Parameters:

• position – is the global position where the normal vector is constructed

• gctx – The current geometry context object, e.g. alignment

Returns:

normal vector by value

CylinderSurface &operator=(const CylinderSurface &other)

Assignment operator.

Parameters:

other – is the source cylinder for the copy

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Path correction due to incident of the track.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position as a starting point

• direction – is the global momentum direction at the starting point

Returns:

is the correction factor due to incident

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments = 2u) const override

Return a Polyhedron for a cylinder.

This method represents the cylinder as a polyhedron with a given number of segments to represent a quarter of a full circle. The polyedron will consist of the vertices of the cylinder on both sides, and faces between them, both as rectangular faces and as triangular faces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – The number of segments to approximate a quarter of the full circle; it’s chosen to be 1, only the extrema points (-pi, -0.5pi, 0., 0.5pi) are inserted to capture the correct extent in the x-y plane

Returns:

A list of vertices and a face/facett description of it

virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Return the measurement frame - this is needed for alignment, in particular The measurement frame of a cylinder is the tangential plane at a given position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the position where the measurement frame is defined

• direction – is the momentum direction vector (ignored)

Returns:

rotation matrix that defines the measurement frame

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

The binning position method - is overloaded for r-type binning.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the axis Direction of global binning to be done

Returns:

is the global position to be used for binning

virtual Vector3 rotSymmetryAxis(const GeometryContext &gctx) const

Return method for the rotational symmetry axis.

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

the z-Axis of transform

virtual SurfaceType type() const override

Return the surface type.

class CylinderVolumeBounds : public Acts::VolumeBounds

[0] and [1] at positive \( \phi \)

Bounds for a cylindrical Volume, the orientedSurfaces(..) method creates a vector of up to 6 surfaces:

case A) 3 Surfaces (full cylindrical tube): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at negative \( z\)

• positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at positive \( z\)

• cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume

case B) 4 Surfaces (tube with inner and outer radius): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at negative \( z\)

• positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at positive \( z\)

• tubeOuterCover [2] : Acts::CylinderSurface with \( r = r_{outer} \)

• tubeInnerCover [3] : Acts::CylinderSurface with \( r = r_{inner} \)

case C) 6 Surfaces (sectoral tube with inner and outer radius): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Acts::DiscSurface with \( r_{inner}>0\) and \( \phi < \pi \), parallel to \( xy \) plane at negative \(z\)

• positiveFaceXY [1] : Acts::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at positive \(z\)

• tubeSectorOuterCover [2] : Acts::CylinderSurface with \( r = r_{outer}\)

• tubeSectorInnerCover [3] : Acts::CylinderSurface with \( r = r_{inner} \)

• tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to [0] and [1] at negative \( \phi \)

  • tubeSectorNegativePhi [5] :

Public Types

enum BoundValues

for streaming and access

Values:

enumerator eMinR

enumerator eMaxR

enumerator eHalfLengthZ

enumerator eHalfPhiSector

enumerator eAveragePhi

enumerator eBevelMinZ

enumerator eBevelMaxZ

enumerator eSize

enum class Face : unsigned int

Enum describing the possible faces of a cylinder volume.

Note

These values are synchronized with the BoundarySurfaceFace enum. Once Gen1 is removed, this can be changed.

Values:

enumerator PositiveDisc

enumerator NegativeDisc

enumerator OuterCylinder

enumerator InnerCylinder

enumerator NegativePhiPlane

enumerator PositivePhiPlane

Public Functions

CylinderVolumeBounds() = delete

CylinderVolumeBounds(const CylinderBounds &cBounds, double thickness)

Constructor - extruded from cylinder bounds and thickness.

Parameters:

• cBounds – the cylinder bounds

• thickness – of the extrusion

CylinderVolumeBounds(const CylinderVolumeBounds &cylbo)

Copy Constructor.

Parameters:

cylbo – is the source cylinder volume bounds for the copy

CylinderVolumeBounds(const RadialBounds &rBounds, double thickness)

Constructor - extruded from radial bounds and thickness.

Parameters:

• rBounds – the Radial bounds

• thickness –

CylinderVolumeBounds(const std::array<double, eSize> &values)

Constructor - from a fixed size array.

Parameters:

values – The bound values

CylinderVolumeBounds(double rmin, double rmax, double halfz, double halfphi = std::numbers::pi, double avgphi = 0., double bevelMinZ = 0., double bevelMaxZ = 0.)

Constructor.

Parameters:

• rmin – The inner radius of the cylinder

• rmax – The outer radius of the cylinder

• halfz – The half length in z

• halfphi – The half lopening angle

• avgphi – The average phi value

• bevelMinZ – The bevel angle, in radians, for the negative side

• bevelMaxZ – The bevel angle, in radians, for the positive side

~CylinderVolumeBounds() override = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline virtual std::vector<AxisDirection> canonicalAxes() const override

Get the canonical binning directions, i.e.

the axis directions that fully describe the shape’s extent

Returns:

vector of canonical binning values

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector3 &pos, double tol = 0.) const override

This method checks if position in the 3D volume frame is inside the cylinder.

Parameters:

• pos – is a global position to be checked

• tol – is the tolerance for the check

CylinderVolumeBounds &operator=(const CylinderVolumeBounds &cylbo) = default

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

virtual double referenceBorder(AxisDirection aDir) const override

Binning borders in double.

Parameters:

aDir – is the axis direction used for the binning

virtual Vector3 referenceOffset(AxisDirection aDir) const override

Binning offset - overloaded for some R-binning types.

Parameters:

aDir – is the axis direction used for the binning

void set(BoundValues bValue, double value)

Set a bound value.

Parameters:

• bValue – the bound value identifier

• value – the value to be set

void set(std::initializer_list<std::pair<BoundValues, double>> keyValues)

Set a range of bound values.

Parameters:

keyValues – the initializer list of key value pairs

virtual std::ostream &toStream(std::ostream &os) const override

Output Method for std::ostream.

Parameters:

os – is the output stream

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class CylinderVolumeBuilder : public Acts::ITrackingVolumeBuilder

A volume builder to be used for building concentric cylinder volumes.

• a) configured volume

• b) wrapping around a cylindrical/disk layer config

All are optionally wrapped around a given volume which has to by a cylinder volume and which has to be center at z == 0

To receive the tracking volume it is possible to also hand over a triple of layers, which is a C++ tuple of three pointers to layer vectors (defined in the ITrackingVolumeBuilder). This functionality is needed for a possible translation of an geometry existing in another format. The first entry represents the layers of the negative endcap, the second the layers of the barrel and the third the layers of the positive endcap. If the one of these pointers is a nullptr no layers will be created for this volume

For the endcap region it is possible to check for a ring layout, in which case an attempt to split into individual ring volumes is done

Public Functions

CylinderVolumeBuilder(const Config &cvbConfig, std::unique_ptr<const Logger> logger = getDefaultLogger("CylinderVolumeBuilder", Logging::INFO))

Constructor.

Parameters:

• cvbConfig – [in] is the configuration struct to steer the builder

• logger – [in] logging instance

~CylinderVolumeBuilder() override

Destructor.

VolumeConfig analyzeContent(const GeometryContext &gctx, const LayerVector &lVector, const MutableTrackingVolumeVector &mtvVector) const

Analyze the config to gather needed dimension.

Parameters:

• gctx – [in] the geometry context for this building

• lVector – [in] is the vector of layers that are parsed

• mtvVector – [in] Vector of mutable tracking volumes to analyze

Returns:

a VolumeConfig representing this layer

inline Config getConfiguration() const

Get configuration method.

Return the configuration object.

Returns:

a copy of the config object

void setConfiguration(const Config &cvbConfig)

Set configuration method.

Parameters:

cvbConfig – [in] is the new configuration to be set

void setLogger(std::unique_ptr<const Logger> newLogger)

set logging instance

Parameters:

newLogger – [in] is the logging instance to be set

virtual MutableTrackingVolumePtr trackingVolume(const GeometryContext &gctx, TrackingVolumePtr existingVolume = nullptr, std::shared_ptr<const VolumeBounds> externalBounds = nullptr) const override

CylinderVolumeBuilder main call method.

Parameters:

• gctx – [in] geometry context for which this cylinder volume is built

• existingVolume – [in] is an (optional) volume to be included

• externalBounds – [in] are (optional) external confinement constraints

Returns:

a mutable pointer to a new TrackingVolume which includes the optionally provided existingVolume consistently for further processing

struct Config

Nested configuration struct for this CylinderVolumeBuilder.

Public Members

std::array<std::shared_ptr<const ISurfaceMaterial>, 6> boundaryMaterial{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}

—————–&#8212; MB (outer [1]) ————&#8212; | MB [2] NEC MB [3] | B | MB [4] PEC MB [5] | —————–&#8212; MB (inner [0]) ————&#8212;

bool buildToRadiusZero = false

Build the volume to the beam line.

bool checkRingLayout = false

Check for endcap ring layout.

std::shared_ptr<const IConfinedTrackingVolumeBuilder> ctVolumeBuilder = nullptr

Builder to construct confined volumes within the volume.

std::shared_ptr<const ILayerBuilder> layerBuilder = nullptr

Builder to construct layers within the volume.

std::pair<double, double> layerEnvelopeR = {1. * UnitConstants::mm, 1. * UnitConstants::mm}

Additional envelope in R to create rMin, rMax.

double layerEnvelopeZ = 1. * UnitConstants::mm

the additional envelope in Z to create zMin, zMax

double ringTolerance = 0 * UnitConstants::mm

Tolerance for endcap ring association.

std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr

The tracking volume helper for construction.

std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr

The world material.

std::string volumeName = ""

The string based identification.

class CylinderVolumeStack : public Acts::Volume

This class implements a z-aligned or r-aligned stack of cylinder volumes with synchronized bounds.

Externally, it presents as a single volume. On construction, the input volumes are modified so that they are connected in z and r and have synchronized bounds. The way this is done can be configured using an attachment and a resize strategy. Depending on the configuration, the input volumes are either extended or gap volumes are created.

Note

The volumes are never shrunk, because this would potentially result in overlaps of the resulting volumes bounds.

Public Functions

CylinderVolumeStack(std::vector<Volume*> &volumes, AxisDirection direction, VolumeAttachmentStrategy strategy = VolumeAttachmentStrategy::Midpoint, VolumeResizeStrategy resizeStrategy = VolumeResizeStrategy::Expand, const Logger &logger = Acts::getDummyLogger())

Constructor from a vector of volumes and direction.

Note

resizeStrategy only affects resizing along direction. Resizing in the other direction is always delegated to the child volumes, which might in turn be CylinderVolumeStack

Note

Preconditions are checked on construction

Parameters:

• volumes – is the vector of volumes

• direction – is the binning direction

• strategy – is the attachment strategy

• resizeStrategy – is the resize strategy

• logger – is the logger

Pre:

The volumes need to have a common coordinate system relative to direction. I.e. they need to be aligned in z and cannot have a rotation in x or y.

Pre:

The volumes all need to have CylinerVolumeBounds and cannot have a \(\phi\) sector or bevels.

const std::vector<std::shared_ptr<Volume>> &gaps() const

Access the gap volume that were created during attachment or resizing.

Returns:

the vector of gap volumes

virtual void update(std::shared_ptr<VolumeBounds> volbounds, std::optional<Transform3> transform = std::nullopt, const Logger &logger = getDummyLogger()) override

Update the volume bounds and transform.

This will update the bounds of all volumes in the stack to accommodate the new bounds and optionally create gap volumes according to the resize strategy set during construction.

Parameters:

• volbounds – is the new bounds

• transform – is the new transform

• logger – is the logger

Pre:

The volume bounds need to be of type CylinderVolumeBounds.

class DD4hepDetectorElement : public Acts::TGeoDetectorElement

DetectorElement class implementation for DD4hep geometry.

DetectorElement plugin for DD4hep detector elements. DD4hep is based on TGeo shapes, therefore the DD4hepDetectorElement inherits from TGeoDetectorElement in order to perform the conversion.

The full geometrical information is provided by the TGeoDetectorElement. The DD4hepDetectorElement extends the TGeoDetectorElement by containing a segmentation for the readout.

Public Types

using ContextType = GeometryContext

Broadcast the context type.

using DD4hepVolumeID = dd4hep::DDSegmentation::VolumeID

using Store = std::map<std::string, std::vector<std::shared_ptr<DD4hepDetectorElement>>>

Define a string based story.

Public Functions

DD4hepDetectorElement(const dd4hep::DetElement detElement, const std::string &axes = "XYZ", double scalor = 1., bool isDisc = false, std::shared_ptr<const ISurfaceMaterial> material = nullptr)

Constructor.

Example options are:

• ”XYZ” -> identical frame definition (default value)

• ”YZX” -> node y axis is tracking x axis, etc.

• ”XzY” -> negative node z axis is tracking y axis, etc.

Note

In the translation from a 3D geometry (TGeo) which only knows tubes to a 2D geometry (Tracking geometry) a distinction if the module should be described as a cylinder or a disc surface needs to be done. Since this information can not be taken just from the geometry description (both can be described as TGeoTubeSeg), one needs to set the flag ‘isDisc’ in case a volume with shape TGeoTubeSeg should be translated to a disc surface. Per default it will be translated into a cylindrical surface.

Parameters:

• scalor – is the scale factor for unit conversion if needed

• isDisc – in case the sensitive detector module should be translated as disc (e.g. for endcaps) this flag should be set to true

• material – Optional material of detector element

• detElement – The DD4hep DetElement which should be associated to an ACTS surface

• axes – is the axis orientation with respect to the tracking frame it is a string of the three characters x, y and z (standing for the three axes) There is a distinction between capital and lower case characters :

  • capital -> positive orientation of the axis

  • lower case -> negative orientation of the axis

~DD4hepDetectorElement() override = default

inline const dd4hep::DetElement &sourceElement() const

template<typename, typename H = void, DelegateType = DelegateType::NonOwning>
class Delegate

class DetectorElementBase

Subclassed by Acts::Geant4DetectorElement, Acts::JsonDetectorElement, Acts::TGeoDetectorElement

Public Functions

DetectorElementBase() = default

virtual ~DetectorElementBase() = default

virtual const Surface &surface() const = 0

Return surface representation - const return pattern.

virtual Surface &surface() = 0

Non-const return pattern.

virtual double thickness() const = 0

Returns the thickness of the module.

Returns:

double that indicates the thickness of the module

virtual const Transform3 &transform(const GeometryContext &gctx) const = 0

Return the transform for the Element proxy mechanism.

Parameters:

gctx – The current geometry context object, e.g. alignment

class DiamondBounds : public Acts::PlanarBounds

Bounds for a double trapezoidal (“diamond”), planar Surface.

Public Types

enum BoundValues

Values:

enumerator eHalfLengthXnegY

enumerator eHalfLengthXzeroY

enumerator eHalfLengthXposY

enumerator eHalfLengthYneg

enumerator eHalfLengthYpos

enumerator eSize

Public Functions

inline DiamondBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array.

Parameters:

values – The parameter values

inline DiamondBounds(double halfXnegY, double halfXzeroY, double halfXposY, double halfYneg, double halfYpos) noexcept(false)

Constructor for convex hexagon symmetric about the y axis.

Parameters:

• halfXnegY – is the halflength in x at minimal y

• halfXzeroY – is the halflength in x at y = 0

• halfXposY – is the halflength in x at maximal y

• halfYneg – is the halflength into y < 0

• halfYpos – is the halflength into y > 0

virtual const RectangleBounds &boundingBox() const final

Bounding box parameters.

Returns:

rectangle bounds for a bounding box

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) 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)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

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

Output Method for std::ostream.

Parameters:

sl – is the ostream in which it is dumped

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

virtual std::vector<Vector2> vertices(unsigned int ignoredSegments = 0u) const final

Return the vertices that describe this shape.

Parameters:

ignoredSegments – is an ignored parameter only used for curved bound segments

Returns:

vector for vertices in 2D

class DirectNavigator

A fully guided navigator.

This is a fully guided navigator that progresses through a provided sequence of surfaces.

This can either be used as a validation tool, for truth tracking, or track refitting.

Public Types

using SurfaceSequence = std::vector<const Surface*>

The sequentially crossed surfaces.

Public Functions

inline explicit DirectNavigator(std::unique_ptr<const Logger> _logger = getDefaultLogger("DirectNavigator", Logging::INFO))

inline bool checkTargetValid(const State &state, const Vector3 &position, const Vector3 &direction) const

Check if the current target is still valid.

This function checks if the target is valid. For the direct navigator this is always true.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

True if the target is valid

inline const Surface *currentSurface(const State &state) const

inline const TrackingVolume *currentVolume(const State&) const

inline const IVolumeMaterial *currentVolumeMaterial(const State&) const

inline bool endOfWorldReached(State&) const

inline void handleSurfaceReached(State &state, const Vector3 &position, const Vector3 &direction, const Surface &surface) const

Handle the surface reached.

This function handles the surface reached. For the direct navigator this effectively sets the current surface to the reached surface.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

• surface – The surface reached

inline Result<void> initialize(State &state, const Vector3 &position, const Vector3 &direction, Direction propagationDirection) const

Initialize the navigator.

This function initializes the navigator for a new propagation.

Parameters:

• state – The navigation state

• position – The start position

• direction – The start direction

• propagationDirection – The propagation direction

inline State makeState(const Options &options) const

inline bool navigationBreak(const State &state) const

inline NavigationTarget nextTarget(State &state, const Vector3 &position, const Vector3 &direction) const

Get the next target surface.

This function gets the next target surface for the propagation. For the direct navigator this is always the next surface in the sequence.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

The next target surface

inline const Surface *startSurface(const State &state) const

inline const Surface *targetSurface(const State &state) const

struct Config

The nested configuration struct.

struct Options : public Acts::NavigatorPlainOptions

The nested options struct.

Public Functions

inline explicit Options(const GeometryContext &gctx)

inline void setPlainOptions(const NavigatorPlainOptions &options)

Public Members

double farLimit = std::numeric_limits<double>::max()

The far limit to resolve surfaces.

double nearLimit = -100 * UnitConstants::um

Distance limit to discard intersections “behind us”.

Note

this is only necessary because some surfaces have more than one intersection

SurfaceSequence surfaces

The Surface sequence.

double surfaceTolerance = s_onSurfaceTolerance

The surface tolerance.

struct State

Nested State struct.

It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information

Public Functions

inline explicit State(const Options &options_)

inline bool endOfSurfaces() const

inline const Surface &navSurface() const

inline void nextSurface()

inline int remainingSurfaces() const

inline void resetSurfaceIndex()

Public Members

const Surface *currentSurface = nullptr

Navigation state - external interface: the current surface.

Direction direction = Direction::Forward()

bool navigationBreak = false

Navigation state - external interface: a break has been detected.

Options options

NavigatorStatistics statistics

Navigation statistics.

int surfaceIndex = -1

Index of the next surface to try.

Note

-1 means before the first surface in the sequence and size() means after the last surface in the sequence

class Direction

The direction is always with respect to a given momentum, surface normal or other general axes.

Public Functions

inline constexpr std::size_t index() const

Convert dir to index [0,1] which allows to store direction dependent objects in std::array<T, 2u>

Returns:

either 0 or 1

inline constexpr Direction invert() const

Reverse the direction.

Returns:

an opposite direction

inline constexpr int sign() const

Turns the direction into a signed value.

Returns:

a signed value

std::string toString() const

Public Static Functions

static inline constexpr Direction AlongNormal()

static inline constexpr Direction Backward()

static inline constexpr Direction Forward()

static inline constexpr Direction fromIndex(std::size_t index)

Convert and index [0,1] to a direction e.g.

for sorting in std::array<T, 2u>

Parameters:

index – is the direction at input

static inline constexpr Direction fromScalar(double scalar)

This turns a signed value into a direction.

Will assert on zero.

Parameters:

scalar – is the signed value

Returns:

a direction enum

static inline constexpr Direction fromScalarZeroAsPositive(double scalar)

This turns a signed value into a direction and 0 will be handled as a positive direction.

Only use this when you are convinced that the 0 case is properly handled downstream.

Parameters:

scalar – is the signed value

Returns:

a direction enum

static inline constexpr Direction Negative()

static inline constexpr Direction OppositeNormal()

static inline constexpr Direction Positive()

Friends

inline friend constexpr friend bool operator== (Direction lhs, Direction rhs)

class DiscBounds : public Acts::SurfaceBounds

common base class for all bounds that are in a r/phi frame

• simply introduced to avoid wrong bound assignments to surfaces

Subclassed by Acts::AnnulusBounds, Acts::DiscTrapezoidBounds, Acts::RadialBounds

Public Functions

virtual double binningValuePhi() const = 0

Returns a refererance phi for binning.

virtual double binningValueR() const = 0

Returns a reference radius for binning.

virtual bool coversFullAzimuth() const = 0

Returns true for full phi coverage.

virtual bool insideRadialBounds(double R, double tolerance = 0.) const = 0

Checks if it’s inside the radius.

virtual double rMax() const = 0

Return method for outer Radius.

virtual double rMin() const = 0

Return method for inner Radius.

virtual std::vector<Vector2> vertices(unsigned int quarterSegments = 2u) const = 0

Return the vertices.

Parameters:

quarterSegments – The number of segments used to describe a quarter of a circle, if it is 1, then only the extrema points in phi are inserted next to the segment corners

Returns:

vector for vertices in 2D

class DiscLayer : public virtual Acts::DiscSurface, public Acts::Layer

Class to describe a disc-like detector layer for tracking, it inhertis from both, Layer base class and DiscSurface class.

Public Functions

DiscLayer() = delete

DiscLayer(const DiscLayer &cla) = delete

~DiscLayer() override = default

DiscLayer &operator=(const DiscLayer&) = delete

virtual const DiscSurface &surfaceRepresentation() const override

Transforms the layer into a Surface representation for extrapolation.

Returns:

This method returns a surface reference

virtual DiscSurface &surfaceRepresentation() override

Public Static Functions

static inline std::shared_ptr<DiscLayer> create(const Transform3 &transform, const std::shared_ptr<const DiscBounds> &dbounds, std::unique_ptr<SurfaceArray> surfaceArray = nullptr, double thickness = 0., std::unique_ptr<ApproachDescriptor> ad = nullptr, LayerType laytyp = Acts::passive)

Factory constructor with DiscSurface components.

Parameters:

• transform – is the transform to place the layer in the 3D frame

• dbounds – are the disc bounds that describe the layer dimensions

• surfaceArray – is the array of sensitive surfaces

• thickness – is the layer thickness (along the normal vector)

• ad – is the approach descriptor that provides the approach surface

• laytyp – is the layer type

Returns:

a sharted pointer to the new layer

class DiscSurface : public Acts::RegularSurface

Class for a disc surface (or a segment thereof)

The DiscSurface is defined by the local polar coordinates \( (r,phi) \).

The surface transform positions the disc such that the origin is at \( r=0 \), independent of the provided DiscBounds. The normal vector of the disc (i.e., the local \(z\)-axis) is given by \( \vec e_{z} = \vec e_{r} \times\vec e_{phi} \).

The disc surface The only surface type for which the covariance matrix is NOT given in the reference frame. A conversion from polar to cartesian coordinates needs to happen to transfer the local coordinates onto the cartesian reference frame coordinates.

Subclassed by Acts::DiscLayer

Public Functions

virtual const SurfaceBounds &bounds() const final

This method returns the bounds by reference.

virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Jacobian from local to global

virtual FreeToBoundMatrix freeToBoundJacobian(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the jacobian from global to local which the surface knows best, hence the calculation is done here.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Jacobian from global to local

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Convert a global position to a local one this is the most generic interface, which is implemented by all surfaces.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• direction – is the direction of the local position (ignored for RegularSurface)

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const final

Global to local transformation.

Note

the direction is ignored for Disc surfaces in this calculateion

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position - considered to be on surface but not inside bounds (check is done)

• tolerance – optional tolerance within which a point is considered valid on surface

Returns:

a Result<Vector2> which can be !ok() if the operation fails

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const = 0

Convert a global position to a local one.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

Vector2 globalToLocalCartesian(const GeometryContext &gctx, const Vector3 &position, double tol = 0.) const

Special method for DiscSurface : global<->local from cartesian coordinates.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is a global cartesian 3D position

• tol – The absolute tolerance parameter

Returns:

value is a local polar

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const final

Straight line intersection schema.

Mathematical motivation:

the equation of the plane is given by: \( \vec n \cdot \vec x = \vec n \cdot \vec p,\) where \( \vec n = (n_{x}, n_{y}, n_{z})\) denotes the normal vector of the plane, \( \vec p = (p_{x}, p_{y}, p_{z})\) one specific point on the plane and \( \vec x = (x,y,z) \)

all possible points on the plane.

Given a line with:

\( \vec l(u) = \vec l_{1} + u \cdot \vec v \)

,

the solution for

\( u \) can be written: \( u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}\) If the denominator is 0 then the line lies:

• either in the plane

• perpendicular to the normal of the plane

Note

expected to be normalized (no checking)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The global position as a starting point

• direction – The global direction at the starting point

• boundaryTolerance – The boundary check prescription

• tolerance – the tolerance used for the intersection

Returns:

The SurfaceMultiIntersection object

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

Vector3 localCartesianToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const

Special method for DiscSurface : local<->global transformation when provided cartesian coordinates.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is local 2D position in cartesian coordinates

Returns:

value is a global cartesian 3D position

Vector2 localCartesianToPolar(const Vector2 &lcart) const

Special method for Disc surface : local<->local transformations polar <-> cartesian.

Parameters:

lcart – is local 2D position in cartesian coordinates

Returns:

value is a local position in polar coordinates

Vector2 localPolarToCartesian(const Vector2 &lpolar) const

Special method for DiscSurface : local<->local transformations polar <-> cartesian.

Parameters:

lpolar – is a local position in polar coordinates

Returns:

values is local 2D position in cartesian coordinates

Vector2 localPolarToLocalCartesian(const Vector2 &locpol) const

Special method for DiscSurface : local<->local transformations polar <-> cartesian.

Parameters:

locpol – is a local position in polar coordinates

Returns:

values is local 2D position in cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const final

Local to global transformation For planar surfaces the momentum direction is ignored in the local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

This is the most generic interface, which is implemented by all surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction (ignored for RegularSurface)

Returns:

The global position by value

std::pair<std::shared_ptr<DiscSurface>, bool> mergedWith(const DiscSurface &other, AxisDirection direction, bool externalRotation, const Logger &logger = getDummyLogger()) const

Merge two disc surfaces into a single one.

Note

The surfaces need to be compatible, i.e. have disc bounds that align

Note

The returned boolean is false if this is left or counter-clockwise of other, and true if not.

Parameters:

• other – The other disc surface to merge with

• direction – The binning direction: either AxisR or AxisPhi

• externalRotation – If true, any phi rotation is done in the transform

• logger – The logger to use

Returns:

The merged disc surface and a boolean indicating if surfaces are reversed

virtual std::string name() const override

Return properly formatted class name for screen output.

Vector3 normal(const GeometryContext &gctx) const

Get the normal vector, independent of the location.

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

The normal vector

virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final

Normal vector return.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – The local position is ignored

Returns:

a Vector3 by value

Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Calculate the normal vector of the surface This overload requires an on-surface local position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position where the normal vector is constructed

Returns:

normal vector by value

Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const final

Calculate the normal vector of the surface This overload is fully generic, fulfills the Surface interface and accepts a global position and a direction.

For RegularSurface this is equivalent to the normal overload, ignoring the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – is the global position where the normal vector is constructed

• direction – is the direction of the normal vector (ignored for RegularSurface)

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final

Get the normal vector of this surface at a given global position.

Note

The position is required to be on-surface.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global positiono (for DiscSurface this is ignored)

Returns:

The normal vector

Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the normal vector of the surface This overload accepts a global position.

Parameters:

• position – is the global position where the normal vector is constructed

• gctx – The current geometry context object, e.g. alignment

Returns:

normal vector by value

DiscSurface &operator=(const DiscSurface &other)

Assignment operator.

Parameters:

other – The source sourface for the assignment

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Path correction due to incident of the track.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The global position as a starting point

• direction – The global momentum direction at the starting point

Returns:

The correction factor due to incident

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments) const override

Return a Polyhedron for the surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – Number of segments used to describe the quarter of a full circle

Returns:

A list of vertices and a face/facett description of it

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

A reference position for a given axis direction.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – The axis direction for the reference position request

Returns:

position that can beused for this binning

virtual double referencePositionValue(const GeometryContext &gctx, AxisDirection aDir) const final

A reference position value for a given axis direction.

Note

This calls the parent method except for AxisR

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – the value generated for the reference position

Returns:

float to be used for the binning schema

virtual SurfaceType type() const override

Return the surface type.

class DiscTrapezoidBounds : public Acts::DiscBounds

Class to describe the bounds for a planar DiscSurface.

By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.

Public Types

enum BoundValues

Values:

enumerator eHalfLengthXminR

enumerator eHalfLengthXmaxR

enumerator eMinR

enumerator eMaxR

enumerator eAveragePhi

enumerator eStereo

enumerator eSize

Public Functions

inline DiscTrapezoidBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array.

Parameters:

values – The parameter values

DiscTrapezoidBounds(double halfXminR, double halfXmaxR, double minR, double maxR, double avgPhi = std::numbers::pi / 2., double stereo = 0.) noexcept(false)

Constructor for a symmetric Trapezoid giving min X length, max X length, Rmin and R max.

Parameters:

• halfXminR – half length in X at min radius

• halfXmaxR – half length in X at maximum radius

• minR – inner radius

• maxR – outer radius

• avgPhi – average phi value

• stereo – optional stero angle applied

inline virtual double binningValuePhi() const final

Return a reference phi for binning.

inline virtual double binningValueR() const final

Return a reference radius for binning.

inline virtual bool coversFullAzimuth() const final

Returns true for full phi coverage - obviously false here.

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

inline double halfLengthY() const

This method returns the half length in Y (this is Rmax -Rmin)

inline double halfPhiSector() const

This method returns the halfPhiSector which is covered by the disc.

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None()) const final

This method checks if the radius given in the LocalPosition is inside [rMin,rMax] if only tol0 is given and additional in the phi sector is tol1 is given.

Parameters:

• lposition – is the local position to be checked (in polar coordinates)

• boundaryTolerance – is the boundary check directive

inline virtual bool insideRadialBounds(double R, double tolerance = 0.) const final

Checks if this is inside the radial coverage given the a tolerance.

inline double rCenter() const

This method returns the center radius.

inline virtual double rMax() const final

This method returns outer radius.

inline virtual double rMin() const final

This method returns inner radius.

inline double stereo() const

This method returns the stereo angle.

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

Output Method for std::ostream.

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

virtual std::vector<Vector2> vertices(unsigned int ignoredSegments = 0u) const final

This method returns the xy coordinates of the four corners of the bounds in module coorindates (in xy)

Parameters:

ignoredSegments – is an ignored parameter only used for curved bound segments

Returns:

vector for vertices in 2D

template<typename extension_t = EigenStepperDefaultExtension>
class EigenStepper

Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE:

r = (x,y,z) … global position T = (Ax,Ay,Az) … momentum direction (normalized)

dr/ds = T dT/ds = q/p * (T x B)

with s being the arc length of the track, q the charge of the particle, p the momentum magnitude and B the magnetic field

Public Types

using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>

using Covariance = BoundSquareMatrix

using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>

using Jacobian = BoundMatrix

Jacobian, Covariance and State definitions.

Public Functions

inline explicit EigenStepper(const Config &config)

Constructor with configuration.

Parameters:

config – [in] The configuration of the stepper

explicit EigenStepper(std::shared_ptr<const MagneticFieldProvider> bField)

Constructor requires knowledge of the detector’s magnetic field.

Parameters:

bField – The magnetic field provider

inline double absoluteMomentum(const State &state) const

Absolute momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Create and return the bound state at the current position.

This transports (if necessary) the covariance to the surface and creates a bound state. It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator

Parameters:

• state – [in] State that will be presented as BoundState

• surface – [in] The surface to which we bind the state

• transportCov – [in] Flag steering covariance transport

• freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound

Returns:

A bound state:

• the parameters at the surface

• the stepwise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline double charge(const State &state) const

Charge access.

Parameters:

state – [in] The stepping state (thread-local cache)

CurvilinearState curvilinearState(State &state, bool transportCov = true) const

Create and return a curvilinear state at the current position.

This transports (if necessary) the covariance to the current position and creates a curvilinear state.

Parameters:

• state – [in] State that will be presented as CurvilinearState

• transportCov – [in] Flag steering covariance transport

Returns:

A curvilinear state:

• the curvilinear parameters at given position

• the stepweise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline Vector3 direction(const State &state) const

Momentum direction accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Result<Vector3> getField(State &state, const Vector3 &pos) const

Get the field for the stepping, it checks first if the access is still within the Cell, and updates the cell if necessary.

Parameters:

• state – [inout] is the propagation state associated with the track the magnetic field cell is used (and potentially updated)

• pos – [in] is the field position

inline double getStepSize(const State &state, ConstrainedStep::Type stype) const

Get the step size.

Parameters:

• state – [in] The stepping state (thread-local cache)

• stype – [in] The step size type to be returned

void initialize(State &state, const BoundTrackParameters &par) const

void initialize(State &state, const BoundVector &boundParams, const std::optional<BoundMatrix> &cov, ParticleHypothesis particleHypothesis, const Surface &surface) const

State makeState(const Options &options) const

inline Vector3 momentum(const State &state) const

Momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline std::string outputStepSize(const State &state) const

Output the Step Size - single component.

Parameters:

state – [in,out] The stepping state (thread-local cache)

inline const ParticleHypothesis &particleHypothesis(const State &state) const

Particle hypothesis.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Vector3 position(const State &state) const

Global particle position accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

bool prepareCurvilinearState(State &state) const

If necessary fill additional members needed for curvilinearState.

Compute path length derivatives in case they have not been computed yet, which is the case if no step has been executed yet.

Parameters:

state – [inout] The state of the stepper

Returns:

true if nothing is missing after this call, false otherwise.

inline double qOverP(const State &state) const

QoP direction accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline void releaseStepSize(State &state, ConstrainedStep::Type stype) const

Release the Step size.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• stype – [in] The step size type to be released

void setIdentityJacobian(State &state) const

Method that reset the Jacobian to the Identity for when no bound state are available.

Parameters:

state – [inout] State of the stepper

Result<double> step(State &state, Direction propDir, const IVolumeMaterial *material) const

Perform a Runge-Kutta track parameter propagation step.

Note

The state contains the desired step size. It can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.

Parameters:

• state – [inout] State of the stepper

• propDir – is the direction of propagation

• material – is the optional volume material we are stepping through.

Returns:

the result of the step

inline double time(const State &state) const

Time access.

Parameters:

state – [in] The stepping state (thread-local cache)

void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Note

no check is done if the position is actually on the surface

Template Parameters:

surface_t – the Surface type

Parameters:

• state – [inout] State of the stepper

• surface – [in] is the surface to which the covariance is forwarded to

• freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound

void transportCovarianceToCurvilinear(State &state) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Parameters:

state – [inout] State of the stepper

void update(State &state, const FreeVector &freeParams, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const

Method to update a stepper state to the some parameters.

Parameters:

• state – [inout] State object that will be updated

• freeParams – [in] Free parameters that will be written into state

• boundParams – [in] Corresponding bound parameters used to update jacToGlobal in state

• covariance – [in] The covariance that will be written into state

• surface – [in] The surface used to update the jacToGlobal

void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double qOverP, double time) const

Method to update the stepper state.

Parameters:

• state – [inout] State object that will be updated

• uposition – [in] the updated position

• udirection – [in] the updated direction

• qOverP – [in] the updated qOverP value

• time – [in] the updated time value

template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, Direction direction, ConstrainedStep::Type stype) const

Update step size.

This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• oIntersection – [in] The ObjectIntersection to layer, boundary, etc

• direction – [in] The propagation direction

• stype – [in] The step size type to be set

inline void updateStepSize(State &state, double stepSize, ConstrainedStep::Type stype) const

Update step size - explicitly with a double.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• stepSize – [in] The step size value

• stype – [in] The step size type to be set

inline IntersectionStatus updateSurfaceStatus(State &state, const Surface &surface, std::uint8_t index, Direction propDir, const BoundaryTolerance &boundaryTolerance, double surfaceTolerance, ConstrainedStep::Type stype, const Logger &logger = getDummyLogger()) const

Update surface status.

It checks the status to the reference surface & updates the step size accordingly

Parameters:

• state – [inout] The stepping state (thread-local cache)

• surface – [in] The surface provided

• index – [in] The surface intersection index

• propDir – [in] The propagation direction

• boundaryTolerance – [in] The boundary check for this status update

• surfaceTolerance – [in] Surface tolerance used for intersection

• stype – [in] The step size type to be set

• logger – [in] A Logger instance

struct Config

Public Members

std::shared_ptr<const MagneticFieldProvider> bField

struct Options : public Acts::StepperPlainOptions

Public Functions

inline Options(const GeometryContext &gctx, const MagneticFieldContext &mctx)

inline void setPlainOptions(const StepperPlainOptions &options)

struct State

State for track parameter propagation.

It contains the stepping information and is provided thread local by the propagator

Public Functions

inline State(const Options &optionsIn, MagneticFieldProvider::Cache fieldCacheIn)

Constructor from the initial bound track parameters.

Note

the covariance matrix is copied when needed

Parameters:

• optionsIn – [in] is the options object for the stepper

• fieldCacheIn – [in] is the cache object for the magnetic field

Public Members

Vector3 B_first

Magnetic field evaulations.

Vector3 B_last

Vector3 B_middle

Covariance cov = Covariance::Zero()

bool covTransport = false

Covariance matrix (and indicator) associated with the initial error on track parameters.

FreeVector derivative = FreeVector::Zero()

The propagation derivative.

extension_t extension

Algorithmic extension.

MagneticFieldProvider::Cache fieldCache

This caches the current magnetic field cell and stays (and interpolates) within it as long as this is valid.

See step() code for details.

Jacobian jacobian = Jacobian::Identity()

The full jacobian of the transport entire transport.

BoundToFreeMatrix jacToGlobal = BoundToFreeMatrix::Zero()

Jacobian from local to the global frame.

FreeMatrix jacTransport = FreeMatrix::Identity()

Pure transport jacobian part from runge kutta integration.

Vector3 k1

k_i of the RKN4 algorithm

Vector3 k2

Vector3 k3

Vector3 k4

std::array<double, 4> kQoP = {}

k_i elements of the momenta

std::size_t nSteps = 0

Total number of performed steps.

std::size_t nStepTrials = 0

Totoal number of attempted steps.

Options options

FreeVector pars = FreeVector::Zero()

Internal free vector parameters.

ParticleHypothesis particleHypothesis = ParticleHypothesis::pion()

Particle hypothesis.

double pathAccumulated = 0.

Accummulated path length state.

double previousStepSize = 0.

Last performed step (for overstep limit calculation)

StepperStatistics statistics

Statistics of the stepper.

struct Acts::EigenStepper::State::[anonymous] stepData

Storage of magnetic field and the sub steps during a RKN4 step.

ConstrainedStep stepSize

Adaptive step size of the runge-kutta integration.

class EllipseBounds : public Acts::PlanarBounds

Class to describe the bounds for a planar ellispoid surface.

By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.

Public Types

enum BoundValues

Values:

enumerator eInnerRx

enumerator eInnerRy

enumerator eOuterRx

enumerator eOuterRy

enumerator eHalfPhiSector

enumerator eAveragePhi

enumerator eSize

Public Functions

inline EllipseBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array.

Parameters:

values – The parameter values

inline EllipseBounds(double innerRx, double innerRy, double outerRx, double outerRy, double halfPhi = std::numbers::pi, double averagePhi = 0.) noexcept(false)

Constructor for full of an ellipsoid ring.

Parameters:

• innerRx – The inner ellipse radius in x

• innerRy – The inner ellipse radius in y

• outerRx – The outer ellipse radius in x

• outerRy – The outer ellipse radius in y

• halfPhi – spanning phi sector (is set to pi as default)

• averagePhi – average phi (is set to 0. as default)

virtual const RectangleBounds &boundingBox() const final

Bounding box parameters.

Returns:

rectangle bounds for a bounding box

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) const final

This method checks if the point given in the local coordinates is between two ellipsoids if only tol0 is given and additional in the phi sector is tol1 is given.

Warning

This only works for tolerance-based checks

Parameters:

• lposition – Local position (assumed to be in right surface frame)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

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

Output Method for std::ostream.

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

virtual std::vector<Vector2> vertices(unsigned int quarterSegments) const final

Return the vertices.

Parameters:

quarterSegments – is the number of segments to approximate a quarter of a circle. In order to symmetrize fully closed and sectoral cylinders, also in the first case the two end points are given (albeit they overlap) in -pi / pi

Returns:

vector for vertices in 2D

class Detector : public std::enable_shared_from_this<Detector>

Public Functions

const ExternalNavigationDelegate &detectorVolumeFinder() const

Const access to the volume finder.

const DetectorVolume *findDetectorVolume(const GeometryContext &gctx, const Vector3 &position) const

Find a volume from a position.

Note

this creates internally a NavigationState object

Parameters:

• gctx – is the Geometry context of the call

• position – is the position of the call

Returns:

the volume pointer or nullptr (if outside)

const DetectorVolume *findDetectorVolume(const std::string &name) const

Find a volume by name.

Parameters:

name – with which the volume is searched for

Returns:

the volume pointer or nullptr (if not found)

const Surface *findSurface(GeometryIdentifier id) const

Search for a surface with the given identifier.

Parameters:

id – is the geometry identifier of the surface

Return values:

• nullptr – if no such surface exists

• pointer – to the found surface otherwise.

std::shared_ptr<Detector> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

std::shared_ptr<const Detector> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

const std::string &name() const

Return the name of the detector.

std::vector<std::shared_ptr<DetectorVolume>> &rootVolumePtrs()

Non-const access to the root volumes.

Returns:

the root volume shared pointer

const std::vector<const DetectorVolume*> &rootVolumes() const

Const access to the root volumes.

Returns:

a vector to const DetectorVolume raw pointers

const GeometryHierarchyMap<const Surface*> &sensitiveHierarchyMap() const

Const access to the hierarchy map of all sensitive surfaces.

Returns:

the map which can be queried with GeometryID for ranges

void updateDetectorVolume(const GeometryContext &gctx, NavigationState &nState) const

Update the current volume of a given navigation state.

Parameters:

• gctx – is the Geometry context of the call

• nState – [in, out] is the navigation state

void updateDetectorVolumeFinder(ExternalNavigationDelegate detectorVolumeFinder)

Update the volume finder.

Parameters:

detectorVolumeFinder – the new volume finder

template<MutableSurfaceVisitor visitor_t>
inline void visitMutableSurfaces(visitor_t &&visitor)

Visit all reachable surfaces of the detector - non-const.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Note

due to the fact that this doesn’t run over root volumes, and due to the fact that portals can be shared between volumes, multiple visits may occur, duplicated addressing needs to be taken care of by the

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

template<MutableDetectorVolumeVisitor visitor_t>
inline void visitMutableVolumes(visitor_t &&visitor)

Visit all reachable detector volumes of the detector - non-const.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Note

that due to non running over root volumes, multiple visits may occur, duplicated addressing needs to be taken care of by the visitor

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const

Visit all reachable surfaces of the detector.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Note

due to the fact that portals can be shared between volumes, multiple visits may occur, duplicated addressing needs to be taken care of by the visitor

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

template<DetectorVolumeVisitor visitor_t>
inline void visitVolumes(visitor_t &&visitor) const

Visit all reachable detector volumes of the detector.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

std::vector<std::shared_ptr<DetectorVolume>> &volumePtrs()

Non-const access to the root volume.

Returns:

the volumes shared pointer store

const std::vector<const DetectorVolume*> &volumes() const

Const access to sub volumes.

Returns:

a vector to const DetectorVolume raw pointers

Public Static Functions

static std::shared_ptr<Detector> makeShared(std::string name, std::vector<std::shared_ptr<DetectorVolume>> rootVolumes, ExternalNavigationDelegate detectorVolumeFinder)

Factory for producing memory managed instances of Detector.

class DetectorNavigator

Public Functions

inline explicit DetectorNavigator(Config cfg, std::shared_ptr<const Logger> _logger = getDefaultLogger("DetectorNavigator", Logging::Level::INFO))

Constructor with configuration object.

Parameters:

• cfg – The navigator configuration

• _logger – a logger instance

inline bool checkTargetValid(const State &state, const Vector3 &position, const Vector3 &direction) const

inline const Surface *currentSurface(const State &state) const

inline const DetectorVolume *currentVolume(const State &state) const

inline const IVolumeMaterial *currentVolumeMaterial(const State &state) const

inline bool endOfWorldReached(State &state) const

inline void handleSurfaceReached(State &state, const Vector3 &position, const Vector3 &direction, const Surface &surface) const

inline Result<void> initialize(State &state, const Vector3 &position, const Vector3 &direction, Direction propagationDirection) const

inline State makeState(const Options &options) const

inline bool navigationBreak(const State &state) const

inline NavigationTarget nextTarget(State &state, const Vector3 &position, const Vector3 &direction) const

inline const Surface *startSurface(const State &state) const

inline const Surface *targetSurface(const State &state) const

struct Config

Public Members

const Detector *detector = nullptr

Detector for this Navigation.

bool resolveMaterial = true

stop at every material surface (whether it is passive or not)

bool resolvePassive = false

stop at every surface regardless what it is

bool resolveSensitive = true

Configuration for this Navigator stop at every sensitive surface (whether it has material or not)

struct Options : public Acts::NavigatorPlainOptions

Public Functions

inline explicit Options(const GeometryContext &gctx)

inline void setPlainOptions(const NavigatorPlainOptions &options)

struct State : public Acts::Experimental::NavigationState

Nested State struct.

It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information

Public Functions

inline explicit State(const Options &options_)

Public Members

const Surface *currentSurface = nullptr

Navigation state - external state: the current surface.

bool navigationBreak = false

Navigation state : a break has been detected.

Options options

NavigatorStatistics statistics

Navigation statistics.

class DetectorVolume : public std::enable_shared_from_this<DetectorVolume>

A detector volume description which can be:

Note

A detector volume holds non-const objects internally that are allowed to be modified as long as the geometry is not yet closed. Using this, material can be attached, and GeometryIdentifier can be set at construction time.

Note

The construction of DetectorVolumes is done via a dedicated factory, this is necessary as then the shared_ptr is non-weak and it can be registered in the portal generator for further geometry processing.

Note

Navigation is always done by plain pointers, while object ownership is done by shared/unique pointers.

Public Types

using BoundingBox = Acts::AxisAlignedBoundingBox<Acts::Experimental::DetectorVolume, double, 3>

Public Functions

void assignDetector(const Detector &detector)

Assign Detector to this volume (for back navigation issues)

Parameters:

detector – the parenting detector class

void assignGeometryId(const GeometryIdentifier &geoID)

Set the geometry identifier.

Note

no checking is done, it will overwrite any existing id

Parameters:

geoID – is the geometry Id that is set to the object

void assignInternalNavigation(InternalNavigationDelegate internalNavigation, const std::vector<std::shared_ptr<Surface>> &surfaces = {}, const std::vector<std::shared_ptr<DetectorVolume>> &volumes = {})

This method allows to udate the navigation state updator module.

Parameters:

• internalNavigation – the new navigation state updator for surfaces

• surfaces – the surfaces the new navigation state updator points to

• volumes – the volumes the new navigation state updator points to

void assignVolumeMaterial(std::shared_ptr<const IVolumeMaterial> material)

Assign the volume material description.

This method allows to load a material description during the detector geometry building, and assigning it (potentially multiple) times to detector volumes.

Parameters:

material – Material description associated to this volumw

Vector3 center(const GeometryContext &gctx = GeometryContext()) const

Const access to the center.

Note

the geometry context is currently ignored, but is a placeholder for eventually misaligned volumes

Parameters:

gctx – the geometry context

Returns:

a contextually created center

void closePortals()

Final closing of portal, i.e. this sets the end of world.

const Detector *detector() const

Const access to the detector.

bool exclusivelyInside(const GeometryContext &gctx, const Vector3 &position) const

Check if a point is exclusively inside this volume i.e.

this point is not inside a subvolume.

Parameters:

• gctx – the geometry context

• position – the position for the inside check

Returns:

a bool to indicate inside/outside

Extent extent(const GeometryContext &gctx, std::size_t nseg = 1) const

The Extent for this volume.

Parameters:

• gctx – is the geometry context

• nseg – is the number of segments to approximate

Returns:

an Extent object

const ExternalNavigationDelegate &externalNavigation() const

Const access to the detector volume updator.

const GeometryIdentifier &geometryId() const

Returns:

the geometry identifier

const BoundingBox &getBoundingBox() const

std::shared_ptr<DetectorVolume> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

std::shared_ptr<const DetectorVolume> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

bool inside(const GeometryContext &gctx, const Vector3 &position) const

Check if a point is inside this volume.

Subvolumes will not be checked.

Parameters:

• gctx – the geometry context

• position – the position for the inside check

Returns:

a bool to indicate inside/outside

const InternalNavigationDelegate &internalNavigation() const

Const access to the navigation state updator.

const std::string &name() const

Returns:

the name of the volume

std::vector<std::shared_ptr<Portal>> &portalPtrs()

Non-const access to the portals.

Returns:

the portal shared pointer store

const std::vector<const Portal*> &portals() const

Const access to the detector portals.

Note

an empty vector indicates a container volume that has not been properly connected

Returns:

a vector to const Portal raw pointers

std::vector<std::shared_ptr<Surface>> &surfacePtrs()

Non-const access to the surfaces.

Returns:

the surfaces shared pointer store

const std::vector<const Surface*> &surfaces() const

Const access to the surfaces.

Note

an empty vector indicates either gap volume or container volume, a non-empty vector indicates a layer volume.

Returns:

a vector to const Surface raw pointers

const Transform3 &transform(const GeometryContext &gctx = GeometryContext()) const

Const access to the transform.

Note

the geometry context is currently ignored, but is a placeholder for eventually misaligned volumes

Parameters:

gctx – the geometry context

Returns:

const reference to the contextual transform

void updateNavigationState(const GeometryContext &gctx, NavigationState &nState) const

Initialize/update the navigation status in this environment.

This method calls:

• the local navigation delegate for candidate surfaces

• the portal navigation delegate for candidate exit portals

• set the current detector volume

Parameters:

• gctx – is the current geometry context

• nState – [in,out] is the detector navigation state to be updated

void updatePortal(std::shared_ptr<Portal> portal, unsigned int pIndex) noexcept(false)

Update a portal given a portal index.

Note

throws exception if portal index out of bounds

Parameters:

• portal – the portal to be updated

• pIndex – the portal index

template<MutableSurfaceVisitor visitor_t>
inline void visitMutableSurfaces(visitor_t &&visitor)

Visit all reachable surfaces of the detector - non-const.

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be called for each found surface, it will be handed down to contained volumes and portals

template<MutableDetectorVolumeVisitor visitor_t>
inline void visitMutableVolumes(visitor_t &&visitor)

Visit all reachable detector volumes of the detector - non-const.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const

Visit all reachable surfaces of the detector.

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be called for each found surface, it will be handed down to contained volumes and portals

template<DetectorVolumeVisitor visitor_t>
inline void visitVolumes(visitor_t &&visitor) const

Visit all reachable detector volumes of the detector.

Note

if a context is needed for the visit, the vistitor has to provide it, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be handed to each root volume, eventually contained volumes within the root volumes are handled by the root volume

const VolumeBounds &volumeBounds() const

Const access to the volume bounds.

Returns:

const reference to the volume bounds object

const IVolumeMaterial *volumeMaterial() const

Const access to the volume amterial.

std::vector<std::shared_ptr<DetectorVolume>> &volumePtrs()

Non-const access to the volumes.

Returns:

the volumes shared pointer store

const std::vector<const DetectorVolume*> &volumes() const

Const access to sub volumes.

Note

and empty vector indicates this is either a gap volume or a layer volume, in any case it means the volume is on navigation level and the portals need to be connected

Returns:

a vector to const DetectorVolume raw pointers

Friends

friend class DetectorVolumeFactory

template<typename internal_type>
struct ObjectStore

Nested object store that holds the internal (non-const), reference counted objects and provides an external (const raw pointer) access.

Template Parameters:

internal_type – is the internal storage representation, has to comply with std::shared_ptr semantics

Public Functions

ObjectStore() = default

inline ObjectStore(std::vector<internal_type> objects)

Store constructor.

Parameters:

objects – are the ones copied into the internal store

Public Members

std::vector<const typename internal_type::element_type*> external = {}

The external storage vector, const raw pointer.

std::vector<internal_type> internal = {}

The internal storage vector.

class DetectorVolumeFactory

A detector volume factory which first constructs the detector volume and then constructs the portals.

This ensures that the std::shared_ptr holding the detector volume is not weak when assigning to the portals.

Note

Optional containment check is invoked by setting the number of segments nSeg to be greater than 0

Public Static Functions

static inline std::shared_ptr<DetectorVolume> construct(const PortalGenerator &portalGenerator, const GeometryContext &gctx, const std::string &name, const Transform3 &transform, std::shared_ptr<VolumeBounds> bounds, const std::vector<std::shared_ptr<Surface>> &surfaces, const std::vector<std::shared_ptr<DetectorVolume>> &volumes, ExternalNavigationDelegate externalNavigation, InternalNavigationDelegate internalNavigation, int nSeg = -1)

Create a detector volume - from factory.

static inline std::shared_ptr<DetectorVolume> construct(const PortalGenerator &portalGenerator, const GeometryContext &gctx, std::string name, const Transform3 &transform, std::shared_ptr<VolumeBounds> bounds, InternalNavigationDelegate internalNavigation)

Create a detector volume - from factory.

class Portal

A portal description between the detector volumes.

It has a Surface representation for navigation and propagation and guides from one volume to the next.

The surface can carry material to allow mapping onto portal positions if required.

Public Types

using AttachedDetectorVolumes = std::array<std::vector<std::shared_ptr<DetectorVolume>>, 2u>

The vector of attached volumes forward/backward, this is useful in the geometry building.

Public Functions

Portal() = delete

Portal(std::shared_ptr<RegularSurface> surface)

Constructor from surface w/o portal links.

Parameters:

surface – is the representing surface

void assignGeometryId(const GeometryIdentifier &geometryId)

Set the geometry identifier (to the underlying surface)

Parameters:

geometryId – the geometry identifier to be assigned

void assignPortalNavigation(Direction dir, ExternalNavigationDelegate portalNavigation, std::vector<std::shared_ptr<DetectorVolume>> attachedVolumes)

Update the volume link.

Note

this overwrites the existing link

Parameters:

• dir – the direction of the link

• portalNavigation – is the navigation delegate

• attachedVolumes – is the list of attached volumes for book keeping

void assignPortalNavigation(ExternalNavigationDelegate portalNavigation, std::vector<std::shared_ptr<DetectorVolume>> attachedVolumes) noexcept(false)

Update the volume link, w/o directive, i.e.

it relies that there’s only one remaining link to be set, throws an exception if that’s not the case

Note

this overwrites the existing link

Parameters:

• portalNavigation – is the navigation delegate

• attachedVolumes – is the list of attached volumes for book keeping

AttachedDetectorVolumes &attachedDetectorVolumes()

const std::array<ExternalNavigationDelegate, 2u> &portalNavigation() const

RegularSurface &surface()

Non-const access to the surface reference.

const RegularSurface &surface() const

Const access to the surface representation.

void updateDetectorVolume(const GeometryContext &gctx, NavigationState &nState) const noexcept(false)

Update the current volume.

Parameters:

• gctx – is the Geometry context of this call

• nState – [in,out] the navigation state for the volume to be updated

template<MutableSurfaceVisitor visitor_t>
inline void visitMutableSurface(visitor_t &&visitor)

Visit all reachable surfaces of the detector - non-const.

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be called with the represented surface

template<SurfaceVisitor visitor_t>
inline void visitSurface(visitor_t &&visitor) const

Visit all reachable surfaces of the detector.

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – will be called with the represented surface

Public Static Functions

static std::shared_ptr<Portal> fuse(std::shared_ptr<Portal> &aPortal, std::shared_ptr<Portal> &bPortal) noexcept(false)

Fuse with another portal, this one is kept.

Note

this will combine the portal links from the both portals into a new one, it will throw an exception if the portals are not fusable

Note

if one portal carries material, it will be kept, however, if both portals carry material, an exception will be thrown and the portals are not fusable

Note

Both input portals become invalid, in that their update delegates and attached volumes are reset

Parameters:

• aPortal – is the first portal to fuse

• bPortal – is the second portal to fuse

Friends

friend class DetectorVolume

class GainMatrixSmoother

Kalman trajectory smoother based on gain matrix formalism.

This implements not a single smoothing step, but the full backwards smoothing procedure for a filtered, forward trajectory using the stored linearization.

Public Types

using GetCovariance = Acts::Delegate<TrackStateTraits<MultiTrajectoryTraits::MeasurementSizeMax, false>::Covariance(void*)>

using GetParameters = Acts::Delegate<TrackStateTraits<MultiTrajectoryTraits::MeasurementSizeMax, false>::Parameters(void*)>

Public Functions

Result<void> calculate(void *ts, void *prev_ts, const GetParameters &filtered, const GetCovariance &filteredCovariance, const GetParameters &smoothed, const GetParameters &predicted, const GetCovariance &predictedCovariance, const GetCovariance &smoothedCovariance, const GetCovariance &jacobian, const Logger &logger) const

template<typename traj_t>
inline Result<void> operator()(const GeometryContext &gctx, traj_t &trajectory, std::size_t entryIndex, const Logger &logger = getDummyLogger()) const

Run the Kalman smoothing for one trajectory.

Parameters:

• gctx – [in] The geometry context to be used

• trajectory – [inout] The trajectory to be smoothed

• entryIndex – [in] The index of state to start the smoothing

• logger – [in] Where to write logging information to

Public Members

bool doCovCheckAndAttemptFix = false

Whether to check the covariance matrices if they are semi-positive and if not attempt to correct them.

class GainMatrixUpdater

Kalman update step using the gain matrix formalism.

Public Functions

template<typename traj_t>
inline Result<void> operator()(const GeometryContext&, typename traj_t::TrackStateProxy trackState, const Logger &logger = getDummyLogger()) const

Run the Kalman update step for a single trajectory state.

Template Parameters:

kMeasurementSizeMax –

Parameters:

• trackState – [inout] The track state

• logger – [in] Where to write logging information to

class Geant4DetectorElement : public Acts::DetectorElementBase

Detector element representative for Geant4 sensitive elements.

Public Types

using ContextType = GeometryContext

Broadcast the context type.

Public Functions

Geant4DetectorElement(std::shared_ptr<Surface> surface, const G4VPhysicalVolume &g4physVol, const Transform3 &toGlobal, double thickness)

Constructor with arguments.

Parameters:

• surface – the surface representing this detector element

• g4physVol – the physical volume representing this detector element

• toGlobal – the global transformation before the volume

• thickness – the thickness of this detector element

const G4VPhysicalVolume &g4PhysicalVolume() const

Returns:

to the Geant4 physical volume

virtual const Surface &surface() const override

Return surface associated with this detector element.

virtual Surface &surface() override

Non-const access to surface associated with this detector element.

virtual double thickness() const override

Return the thickness of this detector element.

virtual const Transform3 &transform(const GeometryContext &gctx) const override

Return local to global transform associated with this detector element.

Parameters:

gctx – The current geometry context object, e.g. alignment

class Geant4DetectorSurfaceFactory

A factory to convert Geant4 physical volumes into Geant4 detector elements.

Public Types

using Geant4PassiveSurface = std::shared_ptr<Surface>

using Geant4SensitiveSurface = std::tuple<std::shared_ptr<Geant4DetectorElement>, std::shared_ptr<Surface>>

Public Functions

Geant4DetectorSurfaceFactory() = default

The Geant4 detector element factory.

void construct(Cache &cache, const G4Transform3D &g4ToGlobal, const G4VPhysicalVolume &g4PhysVol, const Options &option)

Construction method of the detector elements.

Parameters:

• cache – [in,out] into which the Elements are filled

• g4ToGlobal – the transformation to global

• g4PhysVol – the current physical volume

• option – the factory creation option

struct Cache

Nested cache that records the conversion status.

Public Members

std::size_t convertedMaterials = 0

matching and conversion statistics: materials

std::size_t convertedSurfaces = 0

matching and conversion statistics: surfaces

std::size_t matchedG4Volumes = 0

matching and conversion statistics: volumes

std::vector<Geant4PassiveSurface> passiveSurfaces

The created non-const surfaces - for further processing,.

std::vector<Geant4SensitiveSurface> sensitiveSurfaces

The created detector elements - for the detector store.

struct Config

Nested configuration struct that holds global lifetime configuration.

struct Options

Nested option struct that allows per call changeable configuration.

Public Members

double convertedMaterialThickness = -1

Converted material thickness (< 0 indicates keeping original thickness)

bool convertMaterial = false

Convert the material.

std::shared_ptr<IGeant4PhysicalVolumeSelector> passiveSurfaceSelector = nullptr

A selector for passive surfaces.

double scaleConversion = 1.

Convert the length scale.

std::shared_ptr<IGeant4PhysicalVolumeSelector> sensitiveSurfaceSelector = nullptr

A selector for sensitive surfaces.

class GenericCuboidVolumeBounds : public Acts::VolumeBounds

Public Functions

GenericCuboidVolumeBounds() = delete

GenericCuboidVolumeBounds(const std::array<Acts::Vector3, 8> &vertices) noexcept(false)

Constructor from a set of vertices.

The ordering is considered to be:

• the first 4 vertices are the “top” face

• the second 4 vertices are the “bottom” face

• both faces are given in counter clock wise order

Parameters:

vertices – The set of input vertices

GenericCuboidVolumeBounds(const std::array<double, BoundValues::eSize> &values) noexcept(false)

Constructor from a fixed size array.

Parameters:

values – The input values

~GenericCuboidVolumeBounds() override = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline virtual std::vector<AxisDirection> canonicalAxes() const override

Get the canonical direction values, i.e.

the axis directions that fully describe the shape’s extent

Returns:

vector of canonical binning values

void draw(IVisualization3D &helper, const Transform3 &transform = Transform3::Identity()) const

Draw this shape using a visualization helper.

Parameters:

• helper – The visualizatin helper

• transform – Optional transformation matrix

virtual bool inside(const Vector3 &gpos, double tol = 0.) const override

Checking if position given in volume frame is inside.

Parameters:

• gpos – is the global position to be checked

• tol – is the tolerance applied for the inside check

Returns:

boolean indicating if the position is inside

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

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

Parameters:

sl – is the output stream to be written into

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

struct BoundValues

This struct helps to symmetrize with the the other volume bounds classes.

Public Static Attributes

static constexpr std::size_t eSize = 24

class GeometryContext : public 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

template<typename value_t>
class GeometryHierarchyMap

Store values mapped into the geometry hierarchy.

The core functionality is to find an equivalent element, i.e. an identifier-value pair, for a given geometry identifier via

auto it = container.find(GeometryIdentifier(...));
if (it != container.end()) {
    ...
}

Trailing zero levels of stored geometry identifiers are used as broadcast values to refer to higher-level objects within the geometry, e.g. a geometry identifier with vanishing approach and sensitive index identifies a layer. An entry will all geometry identifier levels set to zero acts as the global default value.

The container also supports range-based iteration over all stored elements

for (const auto& element : container) {
    ...
}

and index-based access to stored elements and associated geometry identifiers

GeometryIdentifier id3 = container.idAt(3);
const auto& element4 = container.valueAt(4);

Adding elements is potentially expensive as the internal lookup structure must be updated. In addition, modifying an element in-place could change its identifier which would also break the lookup. Thus, the container can not be modified after construction to prevent misuse.

Note

No guarantees are given for the element order when using range-based or index-based access. Any apparent ordering must be considered an implementation detail and might change.

Template Parameters:

value_t – stored value type

Public Types

using InputElement = typename std::pair<GeometryIdentifier, value_t>

Combined geometry identifier and value element. Only used for input.

using Iterator = typename std::vector<value_t>::const_iterator

using Value = value_t

Public Functions

GeometryHierarchyMap() = default

GeometryHierarchyMap(const GeometryHierarchyMap&) = default

GeometryHierarchyMap(GeometryHierarchyMap&&) noexcept = default

inline GeometryHierarchyMap(std::initializer_list<InputElement> elements)

Construct the container from an initializer list.

Parameters:

elements – input initializer list

inline GeometryHierarchyMap(std::vector<InputElement> elements)

Construct the container from the given elements.

Parameters:

elements – input elements (must be unique with respect to identifier)

~GeometryHierarchyMap() = default

inline Iterator begin() const

Return an iterator pointing to the beginning of the stored values.

inline bool contains(const GeometryIdentifier &id) const

Check if the most specific value exists for a given geometry identifier.

This function checks if there is an element matching exactly the given geometry id, or from the element for the next available higher level within the geometry hierarchy.

Parameters:

id – geometry identifier for which existence is being checked

Return values:

• <tt>true</tt> – if a matching element exists

• <tt>false</tt> – if no matching element exists

inline bool empty() const

Check if any elements are stored.

inline Iterator end() const

Return an iterator pointing to the end of the stored values.

inline Iterator find(const GeometryIdentifier &id) const

Find the most specific value for a given geometry identifier.

This can be either from the element matching exactly to the given geometry id, if it exists, or from the element for the next available higher level within the geometry hierarchy.

Parameters:

id – geometry identifier for which information is requested

Return values:

• iterator – to an existing value

• <tt>.end()</tt> – iterator if no matching element exists

inline GeometryIdentifier idAt(std::size_t index) const

Access the geometry identifier for the i-th element with bounds check.

Throws:

std::out_of_range – for invalid indices

GeometryHierarchyMap &operator=(const GeometryHierarchyMap&) = default

GeometryHierarchyMap &operator=(GeometryHierarchyMap&&) noexcept = default

inline std::size_t size() const

Return the number of stored elements.

inline const Value &valueAt(std::size_t index) const

Access the value of the i-th element in the container with bounds check.

Throws:

std::out_of_range – for invalid indices

class GeometryIdentifier

Identifier for geometry nodes within the geometry hierarchy.

An identifier can be split into the following components. They define a hierarchy of objects starting from the high-level volumes:

• Volume

• Boundary surfaces (for a volume)

• Layers (confined within a volume)

• Approach surfaces (for a layer)

• Sensitive surfaces (confined to a layer, also called modules)

Public Types

using Value = std::uint64_t

Public Functions

GeometryIdentifier() = default

Construct default GeometryIdentifier with all values set to zero.

GeometryIdentifier(const GeometryIdentifier&) = default

GeometryIdentifier(GeometryIdentifier&&) = default

inline constexpr GeometryIdentifier(Value encoded)

Construct from an already encoded value.

~GeometryIdentifier() = default

inline constexpr Value approach() const

Return the approach identifier.

inline constexpr Value boundary() const

Return the boundary identifier.

inline constexpr Value extra() const

Return the extra identifier Usage can be experiment-specific, like tagging which kind of detector a surface object corresponds to, or which subsystem it belongs to.

inline constexpr Value layer() const

Return the layer identifier.

GeometryIdentifier &operator=(const GeometryIdentifier&) = default

GeometryIdentifier &operator=(GeometryIdentifier&&) = default

inline constexpr Value passive() const

Return the approach identifier.

inline constexpr Value sensitive() const

Return the sensitive identifier.

inline constexpr GeometryIdentifier &setApproach(Value approach)

Set the approach identifier.

inline constexpr GeometryIdentifier &setBoundary(Value boundary)

Set the boundary identifier.

inline constexpr GeometryIdentifier &setExtra(Value extra)

Set the extra identifier.

inline constexpr GeometryIdentifier &setLayer(Value layer)

Set the layer identifier.

inline constexpr GeometryIdentifier &setPassive(Value approach)

Set the approach identifier - shared with Passive.

inline constexpr GeometryIdentifier &setSensitive(Value sensitive)

Set the sensitive identifier.

inline constexpr GeometryIdentifier &setVolume(Value volume)

Set the volume identifier.

inline constexpr Value value() const

Return the encoded value.

inline constexpr Value volume() const

Return the volume identifier.

class GeometryObject

Base class to provide GeometryIdentifier interface:

• simple set and get

It also provides the referencePosition method for Geometry geometrical object to be binned in BinnedArrays

Subclassed by Acts::Layer, Acts::Surface, Acts::Volume

Public Functions

GeometryObject() = default

Defaulted constructor.

inline GeometryObject(const GeometryIdentifier &geometryId)

Constructor from a value.

Parameters:

geometryId – the geometry identifier of the object

GeometryObject(const GeometryObject&) = default

Defaulted copy constructor.

inline void assignGeometryId(const GeometryIdentifier &geometryId)

Set the value.

Parameters:

geometryId – the geometry identifier to be assigned

inline const GeometryIdentifier &geometryId() const

Returns:

the geometry id by reference

inline GeometryObject &operator=(const GeometryObject &geometryId)

Assignment operator.

Parameters:

geometryId – the source geometryId

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const = 0

Force a binning position method.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the value for which the reference position is requesed

Returns:

vector 3D used for the binning schema

inline virtual double referencePositionValue(const GeometryContext &gctx, AxisDirection aDir) const

Implement the binningValue.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the dobule in which you want to bin

Returns:

float to be used for the binning schema

template<typename T, class ...Axes>
class Grid : public Acts::IGrid

class for describing a regular multi-dimensional grid

Class describing a multi-dimensional, regular grid which can store objects in its multi-dimensional bins. Bins are hyper-boxes and can be accessed either by global bin index, local bin indices or position.

Note

T must be default-constructible.

Template Parameters:

• T – type of values stored inside the bins of the grid

• Axes – parameter pack of axis types defining the grid

Public Types

using const_reference = const value_type&

constant reference type to values stored

using global_iterator_t = Acts::GridGlobalIterator<T, Axes...>

global iterator type

using index_t = std::array<std::size_t, DIM>

index type using local bin indices along each axis

using local_iterator_t = Acts::GridLocalIterator<T, Axes...>

local iterator type

using point_t = std::array<double, DIM>

type for points in d-dimensional grid space

using reference = value_type&

reference type to values stored

using value_type = T

type of values stored

Public Functions

inline Grid(Axes&&... axes)

constructor from parameters pack of axes

Parameters:

axes –

inline Grid(const Axes&... axes)

constructor from parameters pack of axes

Parameters:

axes –

inline Grid(const std::tuple<Axes...> &axes)

Constructor from const axis tuple, this will allow creating a grid with a different value type from a template grid object.

Parameters:

axes –

inline Grid(std::tuple<Axes...> &&axes)

Move constructor from axis tuple.

Parameters:

axes –

inline Grid(TypeTag<T>, Axes&&... axes)

constructor from parameters pack of axes and type tag

Parameters:

axes –

inline Grid(TypeTag<T>, const Axes&... axes)

constructor from parameters pack of axes and type tag

Parameters:

axes –

inline reference at(std::size_t bin)

access value stored in bin with given global bin number

Parameters:

bin – [in] global bin number

Returns:

reference to value stored in bin containing the given point

inline const_reference at(std::size_t bin) const

access value stored in bin with given global bin number

Parameters:

bin – [in] global bin number

Returns:

const-reference to value stored in bin containing the given point

inline reference atLocalBins(const index_t &localBins)

access value stored in bin with given local bin numbers

Parameters:

localBins – [in] local bin indices along each axis

Returns:

reference to value stored in bin containing the given point

Pre:

All local bin indices must be a valid index for the corresponding axis (including the under-/overflow bin for this axis).

inline const_reference atLocalBins(const index_t &localBins) const

access value stored in bin with given local bin numbers

Parameters:

localBins – [in] local bin indices along each axis

Returns:

const-reference to value stored in bin containing the given point

Pre:

All local bin indices must be a valid index for the corresponding axis (including the under-/overflow bin for this axis).

template<class Point>
inline reference atPosition(const Point &point)

access value stored in bin for a given point

Note

The look-up considers under-/overflow bins along each axis. Therefore, the look-up will never fail.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point used to look up the corresponding bin in the grid

Returns:

reference to value stored in bin containing the given point

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

template<class Point>
inline const_reference atPosition(const Point &point) const

access value stored in bin for a given point

Note

The look-up considers under-/overflow bins along each axis. Therefore, the look-up will never fail.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point used to look up the corresponding bin in the grid

Returns:

const-reference to value stored in bin containing the given point

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

inline virtual boost::container::small_vector<const IAxis*, 3> axes() const override

get the axes as an array of IAxis pointers

inline const std::tuple<Axes...> &axesTuple() const

get the axes as a tuple

inline global_iterator_t begin() const

begin iterator for global bins

inline local_iterator_t begin(const std::array<std::vector<std::size_t>, DIM> &navigator) const

begin iterator for local bins

Parameters:

navigator – is local navigator for the grid

inline std::array<double, DIM> binCenter(const index_t &localBins) const

get center position of bin with given local bin numbers

Parameters:

localBins – [in] local bin indices along each axis

Returns:

center position of bin

Pre:

All local bin indices must be a valid index for the corresponding axis (excluding the under-/overflow bins for each axis).

inline point_t binWidth() const

get bin width along each specific axis

Returns:

array giving the bin width alonf all axes

template<class Point>
inline detail::GlobalNeighborHoodIndices<DIM> closestPointsIndices(const Point &position) const

get global bin indices for closest points on grid

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

position – [in] point of interest

Returns:

Iterable thatemits the indices of bins whose lower-left corners are the closest points on the grid to the input.

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid. It must lie within the grid range (i.e. not within a under-/overflow bin).

template<typename converter_t>
inline Grid<typename converter_t::value_type, Axes...> convertGrid(converter_t &cVisitor) const

Convenience function to convert the type of the grid to hold another object type.

This is designed to be most flexible with a converter object as a visitor. If needed, such a visitor could also use caching or other techniques to speed up the conversion.

Template Parameters:

converter_t – the converter type

Parameters:

cVisitor – the converter object as visitor

Returns:

a new grid with the same axes and a different value type

template<typename U>
inline Grid<U, Axes...> convertType() const

Convenience function to convert the type of the grid to hold another object type.

Template Parameters:

U – the new grid value type

Returns:

a new grid with the same axes and a different value type

inline global_iterator_t end() const

end iterator for global bins

inline local_iterator_t end(const std::array<std::vector<std::size_t>, DIM> &navigator) const

end iterator for local bins

Parameters:

navigator – is local navigator for the grid

template<class Point>
inline std::size_t globalBinFromFromLowerLeftEdge(const Point &point) const

determine global bin index of the bin with the lower left edge closest to the given point for each axis

Note

This could be a under-/overflow bin along one or more axes.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point to look up in the grid

Returns:

global index for bin containing the given point

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

inline std::size_t globalBinFromLocalBins(const index_t &localBins) const

determine global bin index from local bin indices along each axis

Parameters:

localBins – [in] local bin indices along each axis

Returns:

global index for bin defined by the local bin indices

Pre:

All local bin indices must be a valid index for the corresponding axis (including the under-/overflow bin for this axis).

template<class Point>
inline std::size_t globalBinFromPosition(const Point &point) const

determine global index for bin containing the given point

Note

This could be a under-/overflow bin along one or more axes.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point to look up in the grid

Returns:

global index for bin containing the given point

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

template<class Point> inline T interpolate (const Point &point) const requires(Concepts

interpolate grid values to given position

Note

This function is available only if the following conditions are fulfilled:

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

• Point must represent a d-dimensional position and support coordinate access using operator[] which should return a double (or a value which is implicitly convertible). Coordinate indices must start at 0.

Note

Bin values are interpreted as being the field values at the lower-left corner of the corresponding hyper-box.

Template Parameters:

• Point – type specifying geometric positions

• U – dummy template parameter identical to T

Parameters:

point – [in] location to which to interpolate grid values. The position must be within the grid dimensions and not lie in an under-/overflow bin along any axis.

Returns:

interpolated value at given position

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

template<class Point>
inline bool isInside(const Point &position) const

check whether given point is inside grid limits

Returns:

true if \(\text{xmin_i} \le x_i < \text{xmax}_i \forall i=0, \dots, d-1\), otherwise false

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

Post:

If true is returned, the global bin containing the given point is a valid bin, i.e. it is neither a underflow nor an overflow bin along any axis.

inline index_t localBinsFromGlobalBin(std::size_t bin) const

determine local bin index for each axis from global bin index

Note

Local bin indices can contain under-/overflow bins along the corresponding axis.

Parameters:

bin – [in] global bin index

Returns:

array with local bin indices along each axis (in same order as given axes object)

template<class Point>
inline index_t localBinsFromLowerLeftEdge(const Point &point) const

determine local bin index of the bin with the lower left edge closest to the given point for each axis

Note

This could be a under-/overflow bin along one or more axes.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point to look up in the grid

Returns:

array with local bin indices along each axis (in same order as given axes object)

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

template<class Point>
inline index_t localBinsFromPosition(const Point &point) const

determine local bin index for each axis from the given point

Note

This could be a under-/overflow bin along one or more axes.

Template Parameters:

Point – any type with point semantics supporting component access through operator[]

Parameters:

point – [in] point to look up in the grid

Returns:

array with local bin indices along each axis (in same order as given axes object)

Pre:

The given Point type must represent a point in d (or higher) dimensions where d is dimensionality of the grid.

inline point_t lowerLeftBinEdge(const index_t &localBins) const

retrieve lower-left bin edge from set of local bin indices

Parameters:

localBins – [in] local bin indices along each axis

Returns:

generalized lower-left bin edge position

Pre:

localBins must only contain valid bin indices (excluding underflow bins).

inline point_t maxPosition() const

get the maximum value of all axes of one grid

Returns:

array returning the maxima of all given axes

inline point_t minPosition() const

get the minimum value of all axes of one grid

Returns:

array returning the minima of all given axes

inline detail::GlobalNeighborHoodIndices<DIM> neighborHoodIndices(const index_t &localBins, std::array<std::pair<int, int>, DIM> &sizePerAxis) const

get global bin indices for neighborhood

Note

Over-/underflow bins are included in the neighborhood.

Note

The size parameter sets the range by how many units each local bin index is allowed to be varied. All local bin indices are varied independently, that is diagonal neighbors are included. Ignoring the truncation of the neighborhood size reaching beyond over-/underflow bins, the neighborhood is of size \(2 \times \text{size}+1\) along each dimension.

Parameters:

• localBins – [in] center bin defined by local bin indices along each axis. If size is negative, center bin is not returned.

• sizePerAxis – [in] size of neighborhood for each axis, how many adjacent bins along each axis are considered

Returns:

set of global bin indices for all bins in neighborhood

inline detail::GlobalNeighborHoodIndices<DIM> neighborHoodIndices(const index_t &localBins, std::size_t size = 1u) const

get global bin indices for neighborhood

Note

Over-/underflow bins are included in the neighborhood.

Note

The size parameter sets the range by how many units each local bin index is allowed to be varied. All local bin indices are varied independently, that is diagonal neighbors are included. Ignoring the truncation of the neighborhood size reaching beyond over-/underflow bins, the neighborhood is of size \(2 \times \text{size}+1\) along each dimension.

Parameters:

• localBins – [in] center bin defined by local bin indices along each axis

• size – [in] size of neighborhood determining how many adjacent bins along each axis are considered

Returns:

set of global bin indices for all bins in neighborhood

inline index_t numLocalBins() const

get number of bins along each specific axis

Note

Not including under- and overflow bins

Returns:

array giving the number of bins along all axes

inline void setExteriorBins(const value_type &value)

set all overflow and underflow bins to a certain value

Parameters:

value – [in] value to be inserted in every overflow and underflow bin of the grid.

inline std::size_t size(bool fullCounter = true) const

total number of bins

Note

This number contains under-and overflow bins along all axes.

Returns:

total number of bins in the grid

inline point_t upperRightBinEdge(const index_t &localBins) const

retrieve upper-right bin edge from set of local bin indices

Parameters:

localBins – [in] local bin indices along each axis

Returns:

generalized upper-right bin edge position

Pre:

localBins must only contain valid bin indices (excluding overflow bins).

Public Static Functions

static inline constexpr std::size_t dimensions()

dimensionality of grid

Returns:

number of axes spanning the grid

Public Static Attributes

static constexpr std::size_t DIM = sizeof...(Axes)

number of dimensions of the grid

class HomogeneousSurfaceMaterial : public Acts::ISurfaceMaterial

It extends the ISurfaceMaterial virtual base class to describe a simple homogeneous material on a surface.

Public Functions

HomogeneousSurfaceMaterial() = default

Default Constructor - defaulted.

HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial &hsm) = default

Copy Constructor.

Parameters:

hsm – is the source material

HomogeneousSurfaceMaterial(const MaterialSlab &full, double splitFactor = 1., MappingType mappingType = MappingType::Default)

Explicit constructor.

Parameters:

• full – are the full material properties

• splitFactor – is the split for pre/post update

• mappingType – is the type of surface mapping associated to the surface

HomogeneousSurfaceMaterial(HomogeneousSurfaceMaterial &&hsm) = default

Copy Move Constructor.

Parameters:

hsm – is the source material

~HomogeneousSurfaceMaterial() override = default

Destructor.

inline double factor(Direction pDir, MaterialUpdateStage mStage) const

The inherited methods - for scale access.

virtual const MaterialSlab &materialSlab(const Vector2 &lp) const final

Return method for full material description of the Surface.

• from local coordinate on the surface

Note

the input parameter is ignored

Parameters:

lp – is the local position used for the (eventual) lookup

Returns:

const MaterialSlab

const MaterialSlab &materialSlab(const Vector2 &lp) const = 0

The inherited methods - for MaterialSlab access.

inline MaterialSlab materialSlab(const Vector2 &lp, Direction pDir, MaterialUpdateStage mStage) const

The inherited methods - for MaterialSlab access.

const MaterialSlab &materialSlab(const Vector3 &gp) const = 0

The inherited methods - for MaterialSlab access.

inline MaterialSlab materialSlab(const Vector3 &gp, Direction pDir, MaterialUpdateStage mStage) const

The inherited methods - for MaterialSlab access.

virtual const MaterialSlab &materialSlab(const Vector3 &gp = Vector3{0., 0., 0.}) const final

Return method for full material description of the Surface.

• from the global coordinates

Note

the input parameter is ignored

Parameters:

gp – is the global position used for the (eventual) lookup

Returns:

const MaterialSlab

HomogeneousSurfaceMaterial &operator=(const HomogeneousSurfaceMaterial &hsm) = default

Assignment operator.

Parameters:

hsm – is the source material

HomogeneousSurfaceMaterial &operator=(HomogeneousSurfaceMaterial &&hsm) = default

Assignment Move operator.

Parameters:

hsm – is the source material

virtual HomogeneousSurfaceMaterial &scale(double factor) final

Scale operator.

• it is effectively a thickness scaling

Parameters:

factor – is the scale factor

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

Output Method for std::ostream.

Parameters:

sl – The outoput stream

class IAxis

Common base class for all Axis instance.

This allows generice handling such as for inspection.

Subclassed by Acts::Axis< AxisType::Equidistant, bdt >, Acts::Axis< AxisType::Variable, bdt >

Public Functions

virtual ~IAxis() = default

Virtual destructor.

virtual std::vector<double> getBinEdges() const = 0

Return a vector of bin edges.

Returns:

Vector which contains the bin edges

virtual AxisBoundaryType getBoundaryType() const = 0

returns the boundary type set in the template param

Returns:

AxisBoundaryType of this axis

virtual double getMax() const = 0

get maximum of binning range

Returns:

maximum of binning range

virtual double getMin() const = 0

get minimum of binning range

Returns:

minimum of binning range

virtual std::size_t getNBins() const = 0

get total number of bins

Returns:

total number of bins (excluding under-/overflow bins)

virtual AxisType getType() const = 0

returns the type of the axis

Returns:

AxisType of this axis

virtual bool isEquidistant() const = 0

returns whether the axis is equidistant

Returns:

bool is equidistant

virtual bool isVariable() const = 0

returns whether the axis is variable

Returns:

bool is variable

template<typename callable_t>
inline decltype(auto) visit(const callable_t &callable) const

Helper function that dispatches from the IAxis base class to a concrete axis type.

It will call the provided callable with a const reference to the concrete axis type.

Template Parameters:

callable_t – the callable type

Parameters:

callable – the callable object

Returns:

the value returned by the callable

Public Static Functions

static std::unique_ptr<IAxis> createEquidistant(AxisBoundaryType aBoundaryType, double min, double max, std::size_t nbins)

Centralized axis factory for equidistant binning.

Parameters:

• aBoundaryType – the axis boundary type

• min – the minimum edge of the axis

• max – the maximum edge of the axis

• nbins – the number of bins

Throws:

std::invalid_argument – if min >= max or nbins == 0

Returns:

a unique pointer to the axis

static std::unique_ptr<IAxis> createVariable(AxisBoundaryType aBoundaryType, const std::vector<double> &edges)

Centralized axis factory for variable binning.

Parameters:

• aBoundaryType – the axis boundary type

• edges – are the bin edges

Throws:

std::invalid_argument – if edges is empty or not strictly increasing

Returns:

a unique pointer to the axis

Friends

inline friend std::ostream &operator<<(std::ostream &os, const IAxis &axis)

Output stream operator.

Parameters:

• os – output stream

• axis – the axis to be printed

Returns:

the output stream

inline friend bool operator==(const IAxis &lhs, const IAxis &rhs)

Check if two axes are equal.

Parameters:

• lhs – first axis

• rhs – second axis

Returns:

true if the axes are equal

class IGeant4PhysicalVolumeSelector

Interface class for selectors from physical volumes.

Subclassed by Acts::Geant4PhysicalVolumeSelectors::AllSelector, Acts::Geant4PhysicalVolumeSelectors::NameSelector, Acts::Geant4PhysicalVolumeSelectors::PositionSelector

Public Functions

virtual ~IGeant4PhysicalVolumeSelector() = default

virtual bool select(const G4VPhysicalVolume &g4Phys) const = 0

The main interface method.

Parameters:

g4Phys – the physical volume to be checked

Returns:

a boolean indicating if it should be selected or not

class ISurfaceMaterial

Virtual base class of surface based material description.

MaterialSlab that are associated to a surface, extended by certain special representations (binned, homogeneous)

Subclassed by Acts::BinnedSurfaceMaterial, Acts::GridSurfaceMaterialT< grid_t, material_accessor_t >, Acts::HomogeneousSurfaceMaterial, Acts::ProtoSurfaceMaterialT< BinningType >

Public Functions

ISurfaceMaterial() = default

Constructor.

inline ISurfaceMaterial(double splitFactor)

Constructor.

Parameters:

splitFactor – is the splitting ratio between pre/post update

inline ISurfaceMaterial(double splitFactor, Acts::MappingType mappingType)

Constructor.

Parameters:

• splitFactor – is the splitting ratio between pre/post update

• mappingType – is the type of surface mapping associated to the surface

virtual ~ISurfaceMaterial() = default

Destructor.

inline double factor(Direction pDir, MaterialUpdateStage mStage) const

Update pre factor.

Parameters:

• pDir – is the positive direction through the surface

• mStage – is the material update directive (onapproach, full, onleave)

inline MappingType mappingType() const

Return the type of surface material mapping.

virtual const MaterialSlab &materialSlab(const Vector2 &lp) const = 0

Return method for full material description of the Surface.

• from local coordinate on the surface

Parameters:

lp – is the local position used for the (eventual) lookup

Returns:

const MaterialSlab

inline MaterialSlab materialSlab(const Vector2 &lp, Direction pDir, MaterialUpdateStage mStage) const

Return method for fully scaled material description of the Surface.

• from local coordinate on the surface

Parameters:

• lp – is the local position used for the (eventual) lookup

• pDir – is the positive direction through the surface

• mStage – is the material update directive (onapproach, full, onleave)

Returns:

MaterialSlab

virtual const MaterialSlab &materialSlab(const Vector3 &gp) const = 0

Return method for full material description of the Surface.

• from the global coordinates

Parameters:

gp – is the global position used for the (eventual) lookup

Returns:

const MaterialSlab

inline MaterialSlab materialSlab(const Vector3 &gp, Direction pDir, MaterialUpdateStage mStage) const

Return method for full material description of the Surface.

• from the global coordinates

Parameters:

• gp – is the global position used for the (eventual) lookup

• pDir – is the positive direction through the surface

• mStage – is the material update directive (onapproach, full, onleave)

Returns:

MaterialSlab

virtual ISurfaceMaterial &scale(double factor) = 0

Scale material.

Parameters:

factor – is the scale factor applied

virtual std::ostream &toStream(std::ostream &sl) const = 0

Output Method for std::ostream, to be overloaded by child classes.

inline std::string toString() const

output into a string

Returns:

the string representation

Friends

inline friend std::ostream &operator<<(std::ostream &out, const ISurfaceMaterial &sm)

output stream operator

Prints information about this object to the output stream using the virtual ISurfaceMaterial::toStream method

Returns:

modified output stream object

class InfiniteBounds : public Acts::SurfaceBounds

templated boundless extension to forward the interface Returns all inside checks to true and can templated for all bounds

Public Functions

inline virtual bool inside(const Vector2&, const BoundaryTolerance&) const final

Method inside() returns true for any case.

ignores input parameters

Returns:

always true

inline virtual std::ostream &toStream(std::ostream &os) const final

Output Method for std::ostream.

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.

Returns:

of the stored values for this SurfaceBounds object

template<typename grid_t>
class InterpolatedBFieldMap : public Acts::InterpolatedMagneticField

interpolate magnetic field value from field values on a given grid

This class implements a magnetic field service which is initialized by a field map defined by:

• a list of field values on a regular grid in some n-Dimensional space,

• a transformation of global 3D coordinates onto this n-Dimensional space.

• a transformation of local n-Dimensional magnetic field coordinates into global (cartesian) 3D coordinates

The magnetic field value for a given global position is then determined by:

• mapping the position onto the grid,

• looking up the magnetic field values on the closest grid points,

• doing a linear interpolation of these magnetic field values.

Template Parameters:

grid_t – The Grid type which provides the field storage and interpolation

Public Types

using FieldType = typename Grid::value_type

using Grid = grid_t

Public Functions

inline InterpolatedBFieldMap(Config cfg)

default constructor

inline Result<Vector3> getField(const Vector3 &position) const

retrieve field at given position

Parameters:

position – [in] global 3D position

Returns:

magnetic field value at the given position

Pre:

The given position must lie within the range of the underlying magnetic field map.

inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const final

Retrieve magnetic field value at a given location.

Requires a cache object created through makeCache().

Parameters:

• position – [in] global 3D position for the lookup

• cache – [inout] Field provider specific cache object

Returns:

magnetic field vector at given position

inline Result<FieldCell> getFieldCell(const Vector3 &position) const

retrieve field cell for given position

Parameters:

position – [in] global 3D position

Returns:

field cell containing the given global position

Pre:

The given position must lie within the range of the underlying magnetic field map.

inline virtual Vector3 getFieldUnchecked(const Vector3 &position) const final

Get a field value without checking if the lookup position is within the interpolation domain.

Parameters:

position – The lookup position in 3D

Returns:

The field value at position

inline const Grid &getGrid() const

Get a const reference on the underlying grid structure.

Returns:

grid reference

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

get the maximum value of all axes of the field map

Returns:

vector returning the maxima of all field map axes

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

get the minimum value of all axes of the field map

Returns:

vector returning the minima of all field map axes

inline virtual std::vector<std::size_t> getNBins() const final

get the number of bins for all axes of the field map

Returns:

vector returning number of bins for all field map axes

inline virtual bool isInside(const Vector3 &position) const final

check whether given 3D position is inside look-up domain

Parameters:

position – [in] global 3D position

Returns:

true if position is inside the defined look-up grid, otherwise false

inline bool isInsideLocal(const ActsVector<DIM_POS> &gridPosition) const

check whether given 3D position is inside look-up domain

Parameters:

gridPosition – [in] local N-D position

Returns:

true if position is inside the defined look-up grid, otherwise false

inline virtual MagneticFieldProvider::Cache makeCache(const MagneticFieldContext &mctx) const final

Make an opaque cache for the magnetic field.

Instructs the specific implementation to generate a Cache instance for magnetic field lookup.

Parameters:

mctx – The magnetic field context to generate cache for

Returns:

Cache The opaque cache object

Public Static Attributes

static constexpr std::size_t DIM_POS = Grid::DIM

struct Cache

Public Functions

inline Cache(const MagneticFieldContext&)

Constructor with magnetic field context.

Public Members

std::optional<FieldCell> fieldCell

bool initialized = false

struct Config

Config structure for the interpolated B field map.

Public Members

Grid grid

grid storing magnetic field values

double scale = 1.

global B-field scaling factor

Note

Negative values for scale are accepted and will invert the direction of the magnetic field.

std::function<Vector3(const FieldType&, const Vector3&)> transformBField

calculating the global 3D coordinates (cartesian) of the magnetic field with the local n dimensional field and the global 3D position as input

std::function< ActsVector< DIM_POS >const Vector3 &)> transformPos

mapping of global 3D coordinates (cartesian) onto grid space

struct FieldCell

struct representing smallest grid unit in magnetic field grid

This type encapsulate all required information to perform linear interpolation of magnetic field values within a confined 3D volume.

Public Functions

inline FieldCell(std::array<double, DIM_POS> lowerLeft, std::array<double, DIM_POS> upperRight, std::array<Vector3, N> fieldValues)

default constructor

Parameters:

• lowerLeft – [in] generalized lower-left corner of hyper box (containing the minima of the hyper box along each Dimension)

• upperRight – [in] generalized upper-right corner of hyper box (containing the maxima of the hyper box along each Dimension)

• fieldValues – [in] field values at the hyper box corners sorted in the canonical order defined in Acts::interpolate

inline Vector3 getField(const ActsVector<DIM_POS> &position) const

retrieve field at given position

Parameters:

position – [in] global 3D position

Returns:

magnetic field value at the given position

Pre:

The given position must lie within the current field cell.

inline bool isInside(const ActsVector<DIM_POS> &position) const

check whether given 3D position is inside this field cell

Parameters:

position – [in] global 3D position

Returns:

true if position is inside the current field cell, otherwise false

Public Static Attributes

static constexpr unsigned int N = 1 << DIM_POS

number of corner points defining the confining hyper-box

class InterpolatedMagneticField : public Acts::MagneticFieldProvider

Subclassed by Acts::InterpolatedBFieldMap< grid_t >

Public Functions

virtual Vector3 getFieldUnchecked(const Vector3 &position) const = 0

Get a field value without checking if the lookup position is within the interpolation domain.

Parameters:

position – The lookup position in 3D

Returns:

The field value at position

virtual std::vector<double> getMax() const = 0

get the maximum value of all axes of the field map

Returns:

vector returning the maxima of all field map axes

virtual std::vector<double> getMin() const = 0

get the minimum value of all axes of the field map

Returns:

vector returning the minima of all field map axes

virtual std::vector<std::size_t> getNBins() const = 0

get the number of bins for all axes of the field map

Returns:

vector returning number of bins for all field map axes

virtual bool isInside(const Vector3 &position) const = 0

check whether given 3D position is inside look-up domain

Parameters:

position – [in] global 3D position

Returns:

true if position is inside the defined look-up grid, otherwise false

class JsonDetectorElement : public Acts::DetectorElementBase

A implementation of a detector element, that is constructed from a JSON description of a surface.

The idea behind this is that it helps importing whole tracking geometries from JSON files. In some parts of the codebase, the existence of a detector element associated to a surface has a specific meaning (e.g., flags surfaces as sensitive).

Public Functions

JsonDetectorElement(const nlohmann::json &jSurface, double thickness)

virtual const Surface &surface() const override

Return surface representation - const return pattern.

virtual Surface &surface() override

Non-const return pattern.

virtual double thickness() const override

Returns the thickness of the module.

Returns:

double that indicates the thickness of the module

virtual const Transform3 &transform(const GeometryContext &gctx) const override

Return the transform for the Element proxy mechanism.

Parameters:

gctx – The current geometry context object, e.g. alignment

class KDTreeTrackingGeometryBuilder : public Acts::ITrackingGeometryBuilder

A Tracking Geometry builder restricted to cylindrical geometries.

It takes some helper tools and a vector of surface objects, together with a ProtoDetector description that is used to query a KDTree for contained surfaces in structures defined by the proto volume.

Public Types

using SurfaceKDT = KDTree<2u, std::shared_ptr<Surface>, double, std::array, 100>

Public Functions

KDTreeTrackingGeometryBuilder(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("KDTreeTrackingGeometryBuilder", Logging::INFO))

Constructor.

Parameters:

• cfg – [in] is the configuration struct for this builder

• logger – [in] logging instance

virtual std::unique_ptr<const TrackingGeometry> trackingGeometry(const GeometryContext &gctx) const final

TrackingGeometry Interface method.

Parameters:

gctx – geometry context of that building call

Returns:

a unique pointer to a TrackingGeometry

struct Config

Nested Configuration for this TrackingGeometryBuilder.

Public Members

std::shared_ptr<const GeometryIdentifierHook> geometryIdentifierHook = std::make_shared<GeometryIdentifierHook>()

Optional geometry identifier hook to be used during closure.

std::string hierarchyIndent = "  "

For screen output.

std::shared_ptr<const LayerCreator> layerCreator = nullptr

The layer creator - for sensitives.

ProtoDetector protoDetector

The proto tracking geometry description.

std::vector<std::shared_ptr<Surface>> surfaces = {}

The created surfaces.

std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr

The tracking volume helper for detector construction.

template<typename propagator_t, typename traj_t>
class KalmanFitter

Kalman fitter implementation.

The Kalman filter contains an Actor and a Sequencer sub-class. The Sequencer has to be part of the Navigator of the Propagator in order to initialize and provide the measurement surfaces.

The Actor is part of the Propagation call and does the Kalman update and eventually the smoothing. Updater, Smoother and Calibrator are given to the Actor for further use:

• The Updater is the implemented kalman updater formalism, it runs via a visitor pattern through the measurements.

• The Smoother is called at the end of the filtering by the Actor.

Measurements are not required to be ordered for the KalmanFilter, measurement ordering needs to be figured out by the navigation of the propagator.

The void components are provided mainly for unit testing.

Template Parameters:

propagator_t – Type of the propagation class

Public Functions

inline KalmanFitter(propagator_t pPropagator, std::unique_ptr<const Logger> _logger = getDefaultLogger("KalmanFitter", Logging::INFO))

template<typename source_link_iterator_t, typename start_parameters_t, typename parameters_t = BoundTrackParameters, TrackContainerFrontend track_container_t>
inline Result<typename track_container_t::TrackProxy> fit(source_link_iterator_t it, source_link_iterator_t end, const start_parameters_t &sParameters, const KalmanFitterOptions<traj_t> &kfOptions, const std::vector<const Surface*> &sSequence, track_container_t &trackContainer) const
requires (isDirectNavigator)

Fit implementation of the forward filter, calls the the filter and smoother/reversed filter.

Note

The input measurements are given in the form of SourceLinks. It’s calibrator_t's job to turn them into calibrated measurements used in the fit.

Template Parameters:

• source_link_iterator_t – Iterator type used to pass source links

• start_parameters_t – Type of the initial parameters

• parameters_t – Type of parameters used for local parameters

• track_container_t – Type of the track container

Parameters:

• it – Begin iterator for the fittable uncalibrated measurements

• end – End iterator for the fittable uncalibrated measurements

• sParameters – The initial track parameters

• kfOptions – KalmanOptions steering the fit

• sSequence – surface sequence used to initialize a DirectNavigator

• trackContainer – Input track container storage to append into

Returns:

the output as an output track

template<typename source_link_iterator_t, typename start_parameters_t, typename parameters_t = BoundTrackParameters, TrackContainerFrontend track_container_t>
inline Result<typename track_container_t::TrackProxy> fit(source_link_iterator_t it, source_link_iterator_t end, const start_parameters_t &sParameters, const KalmanFitterOptions<traj_t> &kfOptions, track_container_t &trackContainer) const
requires (!isDirectNavigator)

Fit implementation of the forward filter, calls the the filter and smoother/reversed filter.

Note

The input measurements are given in the form of SourceLink s. It’s the calibrators job to turn them into calibrated measurements used in the fit.

Template Parameters:

• source_link_iterator_t – Iterator type used to pass source links

• start_parameters_t – Type of the initial parameters

• parameters_t – Type of parameters used for local parameters

• track_container_t – Type of the track container

Parameters:

• it – Begin iterator for the fittable uncalibrated measurements

• end – End iterator for the fittable uncalibrated measurements

• sParameters – The initial track parameters

• kfOptions – KalmanOptions steering the fit

• trackContainer – Input track container storage to append into

Returns:

the output as an output track

class Layer : public virtual Acts::GeometryObject

Base Class for a Detector Layer in the Tracking Geometry.

An actual implemented Detector Layer inheriting from this base class has to inherit from a specific type of Surface as well. In addition, a Layer can carry:

A SurfaceArray of Surfaces holding the actual detector elements or subSurfaces. A pointer to the TrackingVolume (can only be set by such) An active/passive code : 0 - active 1 - passive [….] - other

The search type for compatible surfaces on a layer is [ the higher the number, the faster ]: ——&#8212; Layer internal ———————————————&#8212; -1 - provide all intersection tested without boundary check 0 - provide all intersection tested with boundary check 1 - provide overlap descriptor based without boundary check 2 - provide overlap descriptor based with boundary check

A layer can have substructure regarding:

• m_ssRepresentingSurface -> always exists (1), can have material (2)

• m_ssSensitiveSurfaces -> can or not exist (0,1), can have material (2)

• m_ssApproachSurfaces -> can or not exist (0,1) cam have material (2)

Subclassed by Acts::ConeLayer, Acts::CylinderLayer, Acts::DiscLayer, Acts::NavigationLayer, Acts::PlaneLayer

Public Functions

Layer() = delete

Default Constructor - deleted.

Layer(const Layer&) = delete

Copy Constructor - deleted.

virtual ~Layer() = default

Destructor.

ApproachDescriptor *approachDescriptor()

Non-const version of the approach descriptor.

const ApproachDescriptor *approachDescriptor() const

Return method for the approach descriptor, can be nullptr.

boost::container::small_vector<SurfaceIntersection, 10> compatibleSurfaces(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const NavigationOptions<Surface> &options) const

Decompose Layer into (compatible) surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – Position parameter for searching

• direction – Direction of the parameters for searching

• options – The navigation options

Returns:

list of intersection of surfaces on the layer

virtual bool isOnLayer(const GeometryContext &gctx, const Vector3 &position, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None()) const

geometrical isOnLayer() method

Note

using isOnSurface() with Layer specific tolerance

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be checked

• boundaryTolerance – is the boundary check directive

Returns:

boolean that indicates success of the operation

LayerType layerType() const

return the LayerType

const Layer *nextLayer(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Fast navigation to next layer.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the start position for the search

• direction – is the direction for the search

Returns:

the pointer to the next layer

Layer &operator=(const Layer &layer) = delete

Assignment operator - forbidden, layer assignment must not be ambiguous.

Parameters:

layer – is the source layer for assignment

const Volume *representingVolume() const

Return the abstract volume that represents the layer.

Returns:

the representing volume of the layer

virtual bool resolve(bool resolveSensitive, bool resolveMaterial, bool resolvePassive) const

Accept layer according to the following collection directives.

Parameters:

• resolveSensitive – is the prescription to find the sensitive surfaces

• resolveMaterial – is the precription to find material surfaces

• resolvePassive – is the prescription to find all passive surfaces

Returns:

a boolean whether the layer is accepted for processing

template<typename options_t>
inline bool resolve(const options_t &options) const

Accept layer according to the following collection directives.

Template Parameters:

options_t – Type of the options for navigation

Returns:

a boolean whether the layer is accepted for processing

SurfaceArray *surfaceArray()

Non-const version.

const SurfaceArray *surfaceArray() const

Return the entire SurfaceArray, returns a nullptr if no SurfaceArray.

SurfaceIntersection surfaceOnApproach(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const NavigationOptions<Layer> &options) const

Surface seen on approach for layers without sub structure, this is the surfaceRepresentation for layers with sub structure, this is the approachSurface.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – Position for searching

• direction – Direction for searching

• options – The navigation options

Returns:

the Surface intersection of the approach surface

virtual const Surface &surfaceRepresentation() const = 0

Transforms the layer into a Surface representation for extrapolation.

Note

the layer can be hosting many surfaces, but this is the global one to which one can extrapolate

virtual Surface &surfaceRepresentation() = 0

double thickness() const

Return the Thickness of the Layer this is by definition along the normal vector of the surfaceRepresentation.

const TrackingVolume *trackingVolume() const

Get the confining TrackingVolume.

Returns:

the pointer to the enclosing volume

class LineBounds : public Acts::SurfaceBounds

Bounds for a LineSurface.

Public Types

enum BoundValues

Values:

enumerator eR

enumerator eHalfLengthZ

enumerator eSize

Public Functions

inline LineBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array.

Parameters:

values – The parameter values

inline LineBounds(double r, double halfZ) noexcept(false)

Constructor.

Parameters:

• r – is the radius of the cylinder, default = 0.

• halfZ – is the half length in z, default = 0.

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 BoundaryTolerance &boundaryTolerance) 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)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

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

Output Method for std::ostream.

Parameters:

sl – is the ostream to be dumped into

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class LineSurface : public Acts::Surface

Base class for a linear surfaces in the TrackingGeometry to describe dirft tube, straw like detectors or the Perigee It inherits from Surface.

Note

It leaves the type() method virtual, so it can not be instantiated

Subclassed by Acts::PerigeeSurface, Acts::StrawSurface

Public Functions

virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. the alignment parameters

virtual const SurfaceBounds &bounds() const final

This method returns the bounds of the surface by reference.

virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Jacobian from local to global

virtual FreeToPathMatrix freeToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

free parameters

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. free parameters

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Specified for LineSurface: global to local method without dynamic memory allocation.

This method is the true global -> local transformation. It makes use of globalToLocal and indicates the sign of the Acts::eBoundLoc0 by the given momentum direction.

The calculation of the sign of the radius (or \( d_0 \)) can be done as follows: May \( \vec d = \vec m - \vec c \) denote the difference between the center of the line and the global position of the measurement/predicted state. Then, \( \vec d \) lies in the so-called measurement plane. The latter is determined by the two orthogonal vectors \( \vec{\texttt{measY}} = \vec{e}_z \) and \( \vec{\texttt{measX}} = \vec{\texttt{measY}} \times \frac{\vec{p}}{|\vec{p}|} \).

The sign of the radius (or \( d_{0} \) ) is then defined by the projection of \( \vec{d} \) on \( \vec{measX} \):\( sign = -sign(\vec{d} \cdot \vec{measX}) \)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position - considered to be on surface but not inside bounds (check is done)

• direction – global 3D momentum direction (optionally ignored)

• tolerance – (unused)

Returns:

A Result<Vector2>, which is set to !ok() if the position is not the point of closest approach to the line surface.

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const final

Calculate the straight-line intersection with the line surface.

Mathematical motivation:

Given two lines in parameteric form:

\( \vec l_{a}(u) = \vec m_a + u \cdot \vec e_{a} \)

\( \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} \)

The vector between any two points on the two lines is given by:

\( \vec s(u, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot \vec e_{b} - u \cdot \vec e_{a} \),

where \( \vec m_{ab} = \vec m_{b} - \vec m_{a} \).

\( \vec s(u_0, \mu_0) \) denotes the vector between the two closest points

\( \vec l_{a,0} = l_{a}(u_0) \) and \( \vec l_{b,0} = l_{b}(\mu_0) \)

and is perpendicular to both, \( \vec e_{a} \) and \( \vec e_{b} \).

This results in a system of two linear equations:

• (i) \( 0 = \vec s(u_0, \mu_0) \cdot \vec e_a = \vec m_{ab} \cdot \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - u_0 \)

• (ii) \( 0 = \vec s(u_0, \mu_0) \cdot \vec e_b = \vec m_{ab} \cdot \vec e_b + \mu_0 - u_0 \vec e_b \cdot \vec e_a \)

Solving (i) and (ii) for \( u \) and \( \mu_0 \) yields:

• \( u_0 = \frac{(\vec m_{ab} \cdot \vec e_a)-(\vec m_{ab} \cdot \vec e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)

• \( \mu_0 = - \frac{(\vec m_{ab} \cdot \vec e_b)-(\vec m_{ab} \cdot \vec e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)

The function checks if \( u_0 \simeq 0\) to check if the current position is at the point of closest approach, i.e. the intersection point, in which case it will return an onSurace intersection result. Otherwise, the path length from position to the point of closest approach ( \( u_0 \)) is returned in a reachable intersection.

Note

expected to be normalized

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The global position as a starting point

• direction – The global direction at the starting point

• boundaryTolerance – The boundary check directive for the estimate

• tolerance – the tolerance used for the intersection

Returns:

is the intersection object

Vector3 lineDirection(const GeometryContext &gctx) const

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

Note

for line surfaces the momentum direction is used in order to interpret the drift radius

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position to be transformed

• direction – is the global momentum direction (used to sign the closest approach)

Returns:

global position by value

virtual std::string name() const override

Return properly formatted class name for screen output.

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const override

Return the surface normal at a given position and direction.

This method is fully generic, and valid for all surface types.

Note

For some surface types, the direction is ignored, but it is not safe to pass in a zero vector!

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – The position at which to calculate the normal

• direction – The direction at which to calculate the normal

Returns:

The normal vector at the given position and direction

LineSurface &operator=(const LineSurface &other)

Assignment operator.

Parameters:

other – is the source surface dor copying

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const override

the pathCorrection for derived classes with thickness is by definition 1 for LineSurfaces

Note

input parameters are ignored

Note

there’s no material associated to the line surface

virtual RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Return the measurement frame - this is needed for alignment, in particular.

for StraightLine and Perigee Surface

• the default implementation is the RotationMatrix3 of the transform

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position where the measurement frame is constructed

• direction – is the momentum direction used for the measurement frame construction

Returns:

is a rotation matrix that indicates the measurement frame

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

The binning position is the position calculated for a certain binning type.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the axis direction for the reference position request

Returns:

position that can beused for this binning

class Logger

class for printing debug output

This class provides the user interface for printing debug messages with different levels of severity.

Public Functions

inline Logger(std::unique_ptr<Logging::OutputPrintPolicy> pPrint, std::unique_ptr<Logging::OutputFilterPolicy> pFilter)

construct from output print and filter policy

Parameters:

• pPrint – [in] policy for printing debug messages

• pFilter – [in] policy for filtering debug messages

inline std::unique_ptr<Logger> clone(const std::optional<std::string> &_name = std::nullopt, const std::optional<Logging::Level> &_level = std::nullopt) const

Make a copy of this logger, optionally changing the name or the level.

Parameters:

• _name – the optional new name

• _level – the optional new level

inline std::unique_ptr<Logger> clone(Logging::Level _level) const

Make a copy of the logger, with a new level.

Convenience function for if you only want to change the level but not the name.

Parameters:

_level – the new level

Returns:

the new logger

inline std::unique_ptr<Logger> cloneWithSuffix(const std::string &suffix, std::optional<Logging::Level> _level = std::nullopt) const

Make a copy of the logger, with a suffix added to the end of it’s name.

You can also optionally supply a new level

Parameters:

• suffix – the suffix to add to the end of the name

• _level – the optional new level

inline bool doPrint(const Logging::Level &lvl) const

decide whether a message with a given debug level has to be printed

Parameters:

lvl – [in] debug level of debug message

Returns:

true if debug message should be printed, otherwise false

inline const Logging::OutputFilterPolicy &filterPolicy() const

Return the filter policy for this logger.

Returns:

the filter policy

inline Logging::Level level() const

Return the level of the filter policy of this logger.

Returns:

the level

inline void log(const Logging::Level &lvl, const std::string &input) const

log a debug message

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

inline const std::string &name() const

Return the name of the print policy of this logger.

Returns:

the name

inline const Logger &operator()() const

Helper function so a logger reference can be used as is with the logging macros.

inline const Logging::OutputPrintPolicy &printPolicy() const

Return the print policy for this logger.

Returns:

the print policy

class DefaultFilterPolicy : public Acts::Logging::OutputFilterPolicy

default filter policy for debug messages

All debug messages with a debug level equal or larger to the specified threshold level are processed.

Public Functions

inline explicit DefaultFilterPolicy(Level lvl)

constructor

Parameters:

lvl – [in] threshold debug level

~DefaultFilterPolicy() override = default

virtual default destructor

inline virtual std::unique_ptr<OutputFilterPolicy> clone(Level level) const override

Make a copy of this filter policy with a new level.

Parameters:

level – the new level

Returns:

the new copy

inline virtual bool doPrint(const Level &lvl) const override

decide whether a debug message should be processed

Parameters:

lvl – [in] debug level of debug message

Returns:

true if lvl >= m_level, otherwise false

inline virtual Level level() const override

Get the level of this filter policy.

Returns:

the levele

class DefaultPrintPolicy : public Acts::Logging::OutputPrintPolicy

default print policy for debug messages

This class allows to print debug messages without further modifications to a specified output stream.

Public Functions

inline explicit DefaultPrintPolicy(std::ostream *out = &std::cout)

constructor

Parameters:

out – [in] pointer to output stream object

Pre:

out is non-zero

inline virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string&) const override

Make a copy of this print policy with a new name.

Returns:

the copy

inline virtual void flush(const Level &lvl, const std::string &input) final

flush the debug message to the destination stream

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

inline virtual const std::string &name() const override

Fulfill OutputPrintPolicy interface.

This policy doesn’t actually have a name, so the assumption is that somewhere in the decorator hierarchy, there is something that returns a name without delegating to a wrappee, before reaching this overload.

Note

This method will throw an exception

Returns:

the name, but it never returns

class LevelOutputDecorator : public Acts::Logging::OutputDecorator

decorate debug message with its debug level

The debug message is complemented with its debug level.

Public Functions

inline explicit LevelOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)

constructor

Parameters:

wrappee – [in] output print policy object to be wrapped

inline virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string &name) const override

Make a copy of this print policy with a new name.

Parameters:

name – the new name

Returns:

the copy

inline virtual void flush(const Level &lvl, const std::string &input) override

flush the debug message to the destination stream

This function prepends the debug level to the debug message and then delegates the flushing of the whole message to its wrapped object.

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

class NamedOutputDecorator : public Acts::Logging::OutputDecorator

decorate debug message with a name

The debug message is complemented with a name.

Public Functions

inline NamedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &name, unsigned int maxWidth = 15)

constructor

Parameters:

• wrappee – [in] output print policy object to be wrapped

• name – [in] name to be added to debug message

• maxWidth – [in] maximum width of field used for name

inline virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string &name) const override

Make a copy of this print policy with a new name.

Parameters:

name – the new name

Returns:

the copy

inline virtual void flush(const Level &lvl, const std::string &input) override

flush the debug message to the destination stream

This function prepends the given name to the debug message and then delegates the flushing of the whole message to its wrapped object.

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

inline virtual const std::string &name() const override

Get this named output decorators name.

Returns:

the name

class OutputDecorator : public Acts::Logging::OutputPrintPolicy

base class for decorating the debug output

Derived classes may augment the debug message with additional information. Chaining different decorators is possible to customize the output to your needs.

Subclassed by Acts::Logging::LevelOutputDecorator, Acts::Logging::NamedOutputDecorator, Acts::Logging::ThreadOutputDecorator, Acts::Logging::TimedOutputDecorator

Public Functions

inline explicit OutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)

constructor wrapping actual output print policy

Parameters:

wrappee – [in] output print policy object which is wrapped by this decorator object

inline virtual void flush(const Level &lvl, const std::string &input) override

flush the debug message to the destination stream

This function delegates the flushing of the debug message to its wrapped object.

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

inline virtual const std::string &name() const override

Return the name of the output decorator (forwards to wrappee)

Returns:

the name

class OutputFilterPolicy

abstract base class for filtering debug output

Implementations of this interface need to define whether a debug message with a certain debug level is processed or filtered out.

Subclassed by Acts::Logging::DefaultFilterPolicy

Public Functions

virtual ~OutputFilterPolicy() = default

virtual default destructor

virtual std::unique_ptr<OutputFilterPolicy> clone(Level level) const = 0

Make a copy of this filter policy with a new level.

Parameters:

level – the new level

Returns:

the new copy

virtual bool doPrint(const Level &lvl) const = 0

decide whether a debug message should be processed

Parameters:

lvl – [in] debug level of debug message

Returns:

true of debug message should be processed, false if debug message should be skipped

virtual Level level() const = 0

Get the level of this filter policy.

Returns:

the levele

class OutputPrintPolicy

abstract base class for printing debug output

Implementations of this interface need to define how and where to print debug messages (e.g. to a file, to a stream into a database etc).

Subclassed by Acts::Logging::DefaultPrintPolicy, Acts::Logging::OutputDecorator

Public Functions

virtual ~OutputPrintPolicy() = default

virtual default destructor

virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string &name) const = 0

Make a copy of this print policy with a new name.

Parameters:

name – the new name

Returns:

the copy

virtual void flush(const Level &lvl, const std::string &input) = 0

handle output of debug message

Parameters:

• lvl – [in] debug output level of message

• input – [in] text of debug message

virtual const std::string &name() const = 0

Return the name of the print policy.

Returns:

the name

class ThreadOutputDecorator : public Acts::Logging::OutputDecorator

decorate debug message with a thread ID

The debug message is complemented with a thread ID.

Public Functions

inline explicit ThreadOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)

constructor

Parameters:

wrappee – [in] output print policy object to be wrapped

inline virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string &name) const override

Make a copy of this print policy with a new name.

Parameters:

name – the new name

Returns:

the copy

inline virtual void flush(const Level &lvl, const std::string &input) override

flush the debug message to the destination stream

This function prepends the thread ID to the debug message and then delegates the flushing of the whole message to its wrapped object.

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

class ThresholdFailure : public std::runtime_error

Custom exception class so threshold failures can be caught.

class TimedOutputDecorator : public Acts::Logging::OutputDecorator

decorate debug message with a time stamp

The debug message is complemented with a time stamp.

Public Functions

inline TimedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee, const std::string &format = "%X")

constructor

Parameters:

• wrappee – [in] output print policy object to be wrapped

• format – [in] format of time stamp (see std::strftime)

inline virtual std::unique_ptr<OutputPrintPolicy> clone(const std::string &name) const override

Make a copy of this print policy with a new name.

Parameters:

name – the new name

Returns:

the copy

inline virtual void flush(const Level &lvl, const std::string &input) override

flush the debug message to the destination stream

This function prepends a time stamp to the debug message and then delegates the flushing of the whole message to its wrapped object.

Parameters:

• lvl – [in] debug level of debug message

• input – [in] text of debug message

class MagneticFieldContext : public 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

class MagneticFieldProvider

Base class for all magnetic field providers.

Subclassed by Acts::ConstantBField, Acts::DD4hepFieldAdapter, Acts::InterpolatedMagneticField, Acts::MultiRangeBField, Acts::NullBField, Acts::SolenoidBField

Public Types

using Cache = Acts::AnyBase<sizeof(char) * 512>

Opaque cache type that can store arbitrary implementation specific cache data.

Examples are an interpolation cell, or an experiment specific conditions data handle.

Public Functions

virtual ~MagneticFieldProvider() = default

virtual Result<Vector3> getField(const Vector3 &position, Cache &cache) const = 0

Retrieve magnetic field value at a given location.

Requires a cache object created through makeCache().

Parameters:

• position – [in] global 3D position for the lookup

• cache – [inout] Field provider specific cache object

Returns:

magnetic field vector at given position

virtual Cache makeCache(const MagneticFieldContext &mctx) const = 0

Make an opaque cache for the magnetic field.

Instructs the specific implementation to generate a Cache instance for magnetic field lookup.

Parameters:

mctx – The magnetic field context to generate cache for

Returns:

Cache The opaque cache object

class Material

Public Types

using ParametersVector = Eigen::Matrix<float, 5, 1>

Public Functions

Material() = default

Construct a vacuum representation.

Material(const Material &mat) = default

explicit Material(const ParametersVector &parameters)

Construct from an encoded parameters vector.

Material(Material &&mat) = default

~Material() = default

inline constexpr float Ar() const

Return the relative atomic mass.

inline bool isValid() const

Check if the material is valid, i.e. it is not vacuum.

inline constexpr float L0() const

Return the nuclear interaction length. Infinity in case of vacuum.

float massDensity() const

Return the mass density.

float meanExcitationEnergy() const

Return the mean electron excitation energy.

inline constexpr float molarDensity() const

Return the molar density.

inline constexpr float molarElectronDensity() const

Return the molar electron density.

Material &operator=(const Material &mat) = default

Material &operator=(Material &&mat) = default

ParametersVector parameters() const

Encode the properties into an opaque parameters vector.

inline constexpr float X0() const

Return the radiation length. Infinity in case of vacuum.

inline constexpr float Z() const

Return the nuclear charge number.

Public Static Functions

static Material fromMassDensity(float x0, float l0, float ar, float z, float massRho)

Construct from material parameters using the mass density.

Warning

Due to the choice of native mass units, using the mass density can lead to numerical problems. Typical mass densities lead to computations with values differing by 20+ orders of magnitude.

Parameters:

• x0 – is the radiation length

• l0 – is the nuclear interaction length

• ar – is the relative atomic mass

• z – is the nuclear charge number

• massRho – is the mass density

static Material fromMolarDensity(float x0, float l0, float ar, float z, float molarRho)

Construct from material parameters using the molar density.

Parameters:

• x0 – is the radiation length

• l0 – is the nuclear interaction length

• ar – is the relative atomic mass

• z – is the nuclear charge number

• molarRho – is the molar density

class MaterialSlab

Material description for an object with defined thickness.

This is intended to describe concrete surface materials.

See also

Material for a description of the available parameters.

Public Functions

MaterialSlab() = default

Construct vacuum without thickness.

MaterialSlab(const Material &material, float thickness)

Construct from material description.

Parameters:

• material – is the material description

• thickness – is the thickness of the material

MaterialSlab(const MaterialSlab&) = default

explicit MaterialSlab(float thickness)

Construct vacuum with thickness.

MaterialSlab(MaterialSlab&&) = default

~MaterialSlab() = default

inline bool isValid() const

Check if the material is valid, i.e. it is finite and not vacuum.

inline constexpr const Material &material() const

Access the (average) material parameters.

MaterialSlab &operator=(const MaterialSlab&) = default

MaterialSlab &operator=(MaterialSlab&&) = default

void scaleThickness(float scale)

Scale the material thickness by the given factor.

inline constexpr float thickness() const

Return the thickness.

inline constexpr float thicknessInL0() const

Return the nuclear interaction length fraction.

inline constexpr float thicknessInX0() const

Return the radiation length fraction.

Public Static Functions

static MaterialSlab averageLayers(const MaterialSlab &layerA, const MaterialSlab &layerB)

Combine material properties of two layers by averaging them.

Parameters:

• layerA – Input layer A to average over.

• layerB – Input layer B to average over.

Returns:

The resulting object has the combined thickness of all layers but just one set of appropriately averaged material constants.

static MaterialSlab averageLayers(const std::vector<MaterialSlab> &layers)

Combine material properties of multiple layers by averaging them.

Parameters:

layers – Input layers to average over.

Returns:

The resulting object has the combined thickness of all layers but just one set of appropriately averaged material constants.

class MeasurementSelector

Measurement selection struct selecting those measurements compatible with the given track parameter against provided criteria on one surface.

The selection criteria could be allowed maximum chi2 and allowed maximum number of measurements on one surface

If there is no compatible measurement, the measurement with the minimum chi2 will be selected and the status will be tagged as an outlier

Public Types

using Config = Acts::GeometryHierarchyMap<MeasurementSelectorCuts>

Geometry-dependent cut configuration.

Different components on the geometry can require different cut settings. The configuration must either contain explicit settings for all geometry components that are used or contain a global default.

Public Functions

MeasurementSelector()

Default constructor.

This will use the default configuration for the cuts.

explicit MeasurementSelector(const Config &config)

Constructor with config.

Parameters:

config – a config instance

explicit MeasurementSelector(const MeasurementSelectorCuts &cuts)

Constructor with cuts.

Parameters:

cuts – The cuts to use

template<typename traj_t>
Result<std::pair<typename std::vector<typename traj_t::TrackStateProxy>::iterator, typename std::vector<typename traj_t::TrackStateProxy>::iterator>> select(std::vector<typename traj_t::TrackStateProxy> &candidates, bool &isOutlier, const Logger &logger) const

Function that select the measurements compatible with the given track parameter on a surface.

Parameters:

• candidates – The track state candidates which already contain predicted parameters

• isOutlier – The indicator for outlier or not

• logger – The logger wrapper

Returns:

Pair of iterators into candidates marking the range of selected candidates

template<typename extension_t = EigenStepperDefaultExtension, typename component_reducer_t = MaxWeightReducerLoop>
class MultiEigenStepperLoop : public Acts::EigenStepper<EigenStepperDefaultExtension>

Stepper based on the EigenStepper, but handles Multi-Component Tracks (e.g., for the GSF).

Internally, this only manages a vector of EigenStepper::States. This simplifies implementation, but has several drawbacks:

• There are certain redundancies between the global State and the component states

• The components do not share a single magnetic-field-cache

Template Parameters:

• extension_t – See EigenStepper for details

• component_reducer_t – How to map the multi-component state to a single component

• small_vector_size – A size-hint how much memory should be allocated by the small vector

Public Types

using BoundState = std::tuple<MultiComponentBoundTrackParameters, Jacobian, double>

Define an own bound state.

using ComponentProxy = detail::LoopComponentProxy<typename State::Component, MultiEigenStepperLoop>

A proxy struct which allows access to a single component of the multi-component state.

It has the semantics of a mutable reference, i.e. it requires a mutable reference of the single-component state it represents

using ConstComponentProxy = detail::LoopComponentProxyBase<const typename State::Component, MultiEigenStepperLoop>

A proxy struct which allows access to a single component of the multi-component state.

It has the semantics of a const reference, i.e. it requires a const reference of the single-component state it represents

using Covariance = BoundSquareMatrix

using CurvilinearState = std::tuple<MultiComponentCurvilinearTrackParameters, Jacobian, double>

Define an own curvilinear state.

using Jacobian = BoundMatrix

Jacobian, Covariance and State definitions.

using Reducer = component_reducer_t

The reducer type.

using SingleOptions = typename SingleStepper::Options

Typedef to the Single-Component Stepper Options.

using SingleState = typename SingleStepper::State

Typedef to the State of the single component Stepper.

using SingleStepper = EigenStepper<extension_t>

Typedef to the Single-Component Eigen Stepper.

Public Functions

inline MultiEigenStepperLoop(const Config &config, std::unique_ptr<const Logger> logger = getDefaultLogger("GSF", Logging::INFO))

Constructor from a configuration and optionally provided Logger.

inline MultiEigenStepperLoop(std::shared_ptr<const MagneticFieldProvider> bField, std::unique_ptr<const Logger> logger = getDefaultLogger("GSF", Logging::INFO))

Constructor from a magnetic field and a optionally provided Logger.

inline double absoluteMomentum(const State &state) const

Absolute momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Result<ComponentProxy> addComponent(State &state, const BoundTrackParameters &pars, double weight) const

Add a component to the Multistepper.

Note

: It is not ensured that the weights are normalized afterwards

Note

This function makes no garantuees about how new components are initialized, it is up to the caller to ensure that all components are valid in the end.

Note

The returned component-proxy is only garantueed to be valid until the component number is again modified

Parameters:

• state – [inout] The stepping state (thread-local cache)

• pars – [in] Parameters of the component to add

• weight – [in] Weight of the component to add

Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Create and return the bound state at the current position.

This transports (if necessary) the covariance to the surface and creates a bound state. It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator.

Note

This is done by combining the gaussian mixture on the specified surface. If the conversion to bound states of some components fails, these components are ignored unless all components fail. In this case an error code is returned.

Parameters:

• state – [in] State that will be presented as BoundState

• surface – [in] The surface to which we bind the state

• transportCov – [in] Flag steering covariance transport

• freeToBoundCorrection – [in] Flag steering non-linear correction during global to local correction

Returns:

A bound state:

• the parameters at the surface

• the stepwise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline double charge(const State &state) const

Charge access.

Parameters:

state – [in] The stepping state (thread-local cache)

inline void clearComponents(State &state) const

Reset the number of components.

Parameters:

state – [inout] The stepping state (thread-local cache)

inline auto componentIterable(State &state) const

Creates an iterable which can be plugged into a range-based for-loop to iterate over components.

Note

Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference

inline auto constComponentIterable(const State &state) const

Creates an constant iterable which can be plugged into a range-based for-loop to iterate over components.

Note

Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference

CurvilinearState curvilinearState(State &state, bool transportCov = true) const

Create and return a curvilinear state at the current position.

This transports (if necessary) the covariance to the current position and creates a curvilinear state.

Note

This is done as a simple average over the free representation and covariance of the components.

Parameters:

• state – [in] State that will be presented as CurvilinearState

• transportCov – [in] Flag steering covariance transport

Returns:

A curvilinear state:

• the curvilinear parameters at given position

• the stepweise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline Vector3 direction(const State &state) const

Momentum direction accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Result<Vector3> getField(State &state, const Vector3 &pos) const

Get the field for the stepping, it checks first if the access is still within the Cell, and updates the cell if necessary.

Note

This uses the cache of the first component stored in the state

Parameters:

• state – [inout] is the propagation state associated with the track the magnetic field cell is used (and potentially updated)

• pos – [in] is the field position

inline double getStepSize(const State &state, ConstrainedStep::Type stype) const

Get the step size.

Note

This returns the smallest step size of all components. It uses std::abs for comparison to handle backward propagation and negative step sizes correctly.

Parameters:

• state – [in] The stepping state (thread-local cache)

• stype – [in] The step size type to be returned

inline void initialize(State &state, const MultiComponentBoundTrackParameters &par) const

inline State makeState(const Options &options) const

inline Vector3 momentum(const State &state) const

Momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline std::size_t numberComponents(const State &state) const

Get the number of components.

Parameters:

state – [in,out] The stepping state (thread-local cache)

inline std::string outputStepSize(const State &state) const

Output the Step Size of all components into one std::string.

Parameters:

state – [in,out] The stepping state (thread-local cache)

inline ParticleHypothesis particleHypothesis(const State &state) const

Particle hypothesis.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Vector3 position(const State &state) const

Global particle position accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline bool prepareCurvilinearState(State &state) const

If necessary fill additional members needed for curvilinearState.

Compute path length derivatives in case they have not been computed yet, which is the case if no step has been executed yet.

Parameters:

state – [inout] The stepping state (thread-local cache)

Returns:

true if nothing is missing after this call, false otherwise.

inline double qOverP(const State &state) const

QoP access.

Parameters:

state – [in] The stepping state (thread-local cache)

inline void releaseStepSize(State &state, ConstrainedStep::Type stype) const

Release the step-size for all components.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• stype – [in] The step size type to be released

inline void removeMissedComponents(State &state) const

Remove missed components from the component state.

Parameters:

state – [in,out] The stepping state (thread-local cache)

inline void reweightComponents(State &state) const

Reweight the components.

Parameters:

state – [inout] The stepping state (thread-local cache)

Result<double> step(State &state, Direction propDir, const IVolumeMaterial *material) const

Perform a Runge-Kutta track parameter propagation step.

The state contains the desired step size. It can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.

Parameters:

• state – [inout] The state of the stepper

• propDir – is the direction of propagation

• material – is the material properties

Returns:

the result of the step

inline double time(const State &state) const

Time access.

Parameters:

state – [in] The stepping state (thread-local cache)

inline void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Note

no check is done if the position is actually on the surface

Template Parameters:

surface_t – the Surface type

Parameters:

• state – [inout] State of the stepper

• surface – [in] is the surface to which the covariance is forwarded

• freeToBoundCorrection – [in] Flag steering non-linear correction during global to local correction to

inline void transportCovarianceToCurvilinear(State &state) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state.

Parameters:

state – [inout] State of the stepper

template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, Direction direction, ConstrainedStep::Type stype) const

Update step size.

This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• oIntersection – [in] The ObjectIntersection to layer, boundary, etc

• direction – [in] The propagation direction

• stype – [in] The step size type to be set

inline void updateStepSize(State &state, double stepSize, ConstrainedStep::Type stype) const

Update step size - explicitly with a double.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• stepSize – [in] The step size value

• stype – [in] The step size type to be set

inline IntersectionStatus updateSurfaceStatus(State &state, const Surface &surface, std::uint8_t index, Direction navDir, const BoundaryTolerance &boundaryTolerance, double surfaceTolerance, ConstrainedStep::Type stype, const Logger &logger = getDummyLogger()) const

Update surface status.

It checks the status to the reference surface & updates the step size accordingly

Parameters:

• state – [inout] The stepping state (thread-local cache)

• surface – [in] The surface provided

• index – [in] The surface intersection index

• navDir – [in] The navigation direction

• boundaryTolerance – [in] The boundary check for this status update

• surfaceTolerance – [in] Surface tolerance used for intersection

• stype – [in] The step size type to be set

• logger – [in] A Logger instance

Public Static Attributes

static constexpr int maxComponents = std::numeric_limits<int>::max()

How many components can this stepper manage?

struct Config

Public Members

std::shared_ptr<const MagneticFieldProvider> bField

struct Options : public SingleOptions

Public Functions

inline Options(const GeometryContext &gctx, const MagneticFieldContext &mctx)

inline void setPlainOptions(const StepperPlainOptions &options)

struct State

Public Functions

inline explicit State(const Options &optionsIn)

Constructor from the initial bound track parameters.

Note

the covariance matrix is copied when needed

Parameters:

optionsIn – [in] is the options object for the stepper

Public Members

SmallVector<Component> components

The components of which the state consists.

bool covTransport = false

Options options

ParticleHypothesis particleHypothesis = ParticleHypothesis::pion()

Particle hypothesis.

double pathAccumulated = 0.

StepperStatistics statistics

The stepper statistics.

std::optional<std::size_t> stepCounterAfterFirstComponentOnSurface

Step-limit counter which limits the number of steps when one component reached a surface.

std::size_t steps = 0

struct Component

The struct that stores the individual components.

Public Functions

inline Component(SingleState state_, double weight_, IntersectionStatus status_)

Public Members

SingleState state

IntersectionStatus status

double weight

template<typename derived_t>
class MultiTrajectory

Store a trajectory of track states with multiple components.

This container supports both simple, sequential trajectories as well as combinatorial or multi-component trajectories. Each point can store a parent point such that the trajectory forms a directed, acyclic graph of sub-trajectories. From a set of endpoints, all possible sub-components can be easily identified. Some functionality is provided to simplify iterating over specific sub-components.

MultiTrajectory track state iteration

template<typename F> void visitBackwards(IndexType iendpoint, F &&callable) const requires detail_lt void applyBackwards (IndexType iendpoint, F &&callable) requires(!ReadOnly) &&detail_lt

Visit all previous states starting at a given endpoint.

Note

Only available if the MultiTrajectory is not read-only Range for the track states from iendpoint to the trajectory start

Note

Const version Range for the track states from iendpoint to the trajectory start, i.e from the outside in.

Note

Only available if the MultiTrajectory is not read-only

Note

Mutable version

Warning

If the trajectory contains multiple components with common points, this can have an impact on the other components.

Param iendpoint:

index of the last state

Param callable:

non-modifying functor to be called with each point Apply a function to all previous states starting at a given endpoint.

Param iendpoint:

index of the last state

Param callable:

modifying functor to be called with each point

Param iendpoint:

Trajectory entry point to start from

Param iendpoint:

Trajectory entry point to start from

Return:

Iterator pair to iterate over

Return:

Iterator pair to iterate over

inline auto forwardTrackStateRange(IndexType istartpoint) const

Range for the track states from istartpoint to the trajectory end, i.e from inside out.

Note

Const version

Parameters:

istartpoint – Trajectory state index for the innermost track state to start from

Returns:

Iterator pair to iterate over

inline auto forwardTrackStateRange(IndexType istartpoint)
requires (!ReadOnly)

Range for the track states from istartpoint to the trajectory end, i.e from inside out.

Note

Only available if the MultiTrajectory is not read-only

Parameters:

istartpoint – Trajectory state index for the innermost track state to start from

Returns:

Iterator pair to iterate over

MultiTrajectory track state (proxy) access and manipulation

These methods allow accessing track states, i.e. adding or retrieving a track state proxy that points at a specific track state in the container.

inline ConstTrackStateProxy getTrackState(IndexType istate) const

Access a read-only point on the trajectory by index.

Note

Only available if the MultiTrajectory is not read-only

Parameters:

istate – The index to access

Returns:

Read only proxy to the stored track state

inline TrackStateProxy getTrackState(IndexType istate)
requires (!ReadOnly)

Access a writable point on the trajectory by index.

Note

Only available if the MultiTrajectory is not read-only

Parameters:

istate – The index to access

Returns:

Read-write proxy to the stored track state

inline IndexType addTrackState(TrackStatePropMask mask = TrackStatePropMask::All, IndexType iprevious = kInvalid)
requires (!ReadOnly)

Add a track state without providing explicit information.

Which components of the track state are initialized/allocated can be controlled via mask

Note

Only available if the MultiTrajectory is not read-only

Parameters:

• mask – The bitmask that instructs which components to allocate and which to leave invalid

• iprevious – index of the previous state, kInvalid if first

Returns:

Index of the newly added track state

inline TrackStateProxy makeTrackState(TrackStatePropMask mask = TrackStatePropMask::All, IndexType iprevious = kInvalid)
requires (!ReadOnly)

Add a track state to the container and return a track state proxy to it This effectively calls addTrackState and getTrackState.

Note

Only available if the track state container is not read-only

Returns:

a track state proxy to the newly added track state

MultiTrajectory column management

MultiTrajectory can manage a set of common static columns, and dynamic columns that can be added at runtime.

This set of methods allows you to manage the dynamic columns.

template<typename T>
inline void addColumn(std::string_view key)
requires (!ReadOnly)

Add a column to the MultiTrajectory.

Note

This takes a string argument rather than a hashed string to maintain compatibility with backends.

Note

Only available if the MultiTrajectory is not read-only

Template Parameters:

T – Type of the column values to add

Parameters:

key – the name of the column to be added

inline bool hasColumn(HashedString key) const

Check if a column with a key key exists.

Parameters:

key – Key to check for a column with

Returns:

True if the column exists, false if not.

Public Types

using ConstTrackStateProxy = Acts::TrackStateProxy<Derived, MeasurementSizeMax, true>

Alias for the const version of a track state proxy, with the same backends as this container.

using Derived = derived_t

using IndexType = typename TrackStateProxy::IndexType

The index type of the track state container.

using TrackStateProxy = Acts::TrackStateProxy<Derived, MeasurementSizeMax, false>

Alias for the mutable version of a track state proxy, with the same backends as this container.

Public Functions

inline void clear()
requires (!ReadOnly)

Clear the MultiTrajectory.

Leaves the underlying storage untouched

Note

Only available if the MultiTrajectory is not read-only

inline IndexType size() const

Returns the number of track states contained.

Returns:

The number of track states

Public Static Attributes

static constexpr IndexType kInvalid = TrackStateProxy::kInvalid

Sentinel value that indicates an invalid index.

static constexpr unsigned int MeasurementSizeMax = MultiTrajectoryTraits::MeasurementSizeMax

static constexpr bool ReadOnly = IsReadOnlyMultiTrajectory<Derived>::value

Friends

friend class MultiTrajectory

friend class TrackStateProxy< Derived, MeasurementSizeMax, false >

friend class TrackStateProxy< Derived, MeasurementSizeMax, true >

class NavigationLayer : public Acts::Layer

Class to be used for gaps in Volumes as a navigational link.

Navigation Layers have a surface representation, but should usually never be propagated to.

Public Functions

NavigationLayer() = delete

Default Constructor - deleted.

NavigationLayer(const NavigationLayer&) = delete

Copy Constructor - deleted.

~NavigationLayer() override

Destructor.

inline virtual bool isOnLayer(const GeometryContext &gctx, const Vector3 &gp, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None()) const final

Geometric isOnLayer() method using isOnSurface() with Layer specific tolerance.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• gp – is the global position for the check

• boundaryTolerance – is the boundary check directive

Returns:

boolean that indicates if the position is on surface

NavigationLayer &operator=(const NavigationLayer&) = delete

Assignment operator - deleted.

inline virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

The binning position method.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the axis direction for which the reference position is requested

  • as default the center is given, but may be overloaded

Returns:

The return vector can be used for binning in a TrackingVolume

inline virtual bool resolve(bool resolveSensitive, bool resolveMaterial, bool resolvePassive) const final

Accept layer according to the following collection directives.

Note

navigation layers are never accepted

Parameters:

• resolveSensitive – is the prescription to find the sensitive surfaces

• resolveMaterial – is the precription to find material surfaces

• resolvePassive – is the prescription to find all passive surfaces

Returns:

a boolean whether the layer is accepted for processing

inline virtual const Surface &surfaceRepresentation() const final

Transforms the layer into a Surface representation for extrapolation In general, extrapolation to a surface should be avoided.

inline virtual Surface &surfaceRepresentation() final

Public Static Functions

static inline LayerPtr create(std::shared_ptr<const Surface> sRepresentation, double thickness = 0.)

Factory Constructor - the surface representation is given by pointer (ownership passed)

Parameters:

• sRepresentation – is the representation for extrapolation

• thickness – is the thickness for the binning

class Navigator

Steers the propagation through the geometry by providing the next surface to be targeted.

The Navigator is part of the propagation and responsible for steering the surface sequence to encounter all the relevant surfaces which are intersected by the trajectory.

The current navigation stage is cached in the state struct and updated when necessary. If any surface in the extrapolation flow is hit, it is set to the navigation state, such that other actors can deal with it.

The current target surface is referenced by an index which points into the navigation candidates. The navigation candidates are ordered by the path length to the surface. If a surface is hit, the state.currentSurface pointer is set. This actors to observe that we are on a surface.

Public Types

using ExternalSurfaces = std::multimap<std::uint64_t, GeometryIdentifier>

using NavigationBoundaries = boost::container::small_vector<BoundaryIntersection, 4>

using NavigationLayers = boost::container::small_vector<LayerIntersection, 10>

using NavigationSurfaces = boost::container::small_vector<SurfaceIntersection, 10>

enum class Stage : int

The navigation stage.

Values:

enumerator initial

enumerator surfaceTarget

enumerator layerTarget

enumerator boundaryTarget

Public Functions

inline explicit Navigator(Config cfg, std::shared_ptr<const Logger> _logger = getDefaultLogger("Navigator", Logging::Level::INFO))

Constructor with configuration object.

Parameters:

• cfg – The navigator configuration

• _logger – a logger instance

inline bool checkTargetValid(const State &state, const Vector3 &position, const Vector3 &direction) const

Check if the current target is still valid.

This function checks if the target is valid.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

True if the target is valid

inline const Surface *currentSurface(const State &state) const

inline const TrackingVolume *currentVolume(const State &state) const

inline const IVolumeMaterial *currentVolumeMaterial(const State &state) const

inline bool endOfWorldReached(const State &state) const

inline void handleSurfaceReached(State &state, const Vector3 &position, const Vector3 &direction, const Surface &surface) const

Handle the surface reached.

This function handles the surface reached.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

• surface – The surface reached

inline Result<void> initialize(State &state, const Vector3 &position, const Vector3 &direction, Direction propagationDirection) const

Initialize the navigator state.

This function initializes the navigator state for a new propagation.

Parameters:

• state – The navigation state

• position – The start position

• direction – The start direction

• propagationDirection – The propagation direction

Returns:

Indication if the initialization was successful

inline State makeState(const Options &options) const

inline bool navigationBreak(const State &state) const

inline NavigationTarget nextTarget(State &state, const Vector3 &position, const Vector3 &direction) const

Get the next target surface.

This function gets the next target surface for the propagation.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

The next target surface

inline const Surface *startSurface(const State &state) const

inline const Surface *targetSurface(const State &state) const

struct Config

The navigator configuration.

Public Members

bool resolveMaterial = true

stop at every material surface (whether it is passive or not)

bool resolvePassive = false

stop at every surface regardless what it is

bool resolveSensitive = true

stop at every sensitive surface (whether it has material or not)

std::shared_ptr<const TrackingGeometry> trackingGeometry = {nullptr}

Tracking Geometry for this Navigator.

struct Options : public Acts::NavigatorPlainOptions

The navigator options.

Public Functions

inline explicit Options(const GeometryContext &gctx)

inline void insertExternalSurface(GeometryIdentifier geoid)

inline void setPlainOptions(const NavigatorPlainOptions &options)

Public Members

ExternalSurfaces externalSurfaces = {}

Externally provided surfaces - these are tried to be hit.

double farLimit = std::numeric_limits<double>::max()

The far limit to resolve surfaces.

double nearLimit = s_onSurfaceTolerance

The near limit to resolve surfaces.

double surfaceTolerance = s_onSurfaceTolerance

The surface tolerance.

struct State

Nested State struct.

It acts as an internal state which is created for every propagation and meant to keep thread-local navigation information.

Public Functions

inline explicit State(const Options &options_)

inline BoundaryIntersection &navBoundary()

inline LayerIntersection &navLayer()

inline SurfaceIntersection &navSurface()

inline void reset()

inline void resetAfterLayerSwitch()

inline void resetAfterVolumeSwitch()

Public Members

const Layer *currentLayer = nullptr

const Surface *currentSurface = nullptr

const TrackingVolume *currentVolume = nullptr

NavigationBoundaries navBoundaries = {}

the vector of boundary surfaces to work through

std::optional<std::size_t> navBoundaryIndex

the current boundary index of the navigation state

bool navigationBreak = false

Stage navigationStage = Stage::initial

std::optional<std::size_t> navLayerIndex

the current layer index of the navigation state

NavigationLayers navLayers = {}

the vector of navigation layers to work through

std::optional<std::size_t> navSurfaceIndex

the current surface index of the navigation state

NavigationSurfaces navSurfaces = {}

the vector of navigation surfaces to work through

Options options

const Layer *startLayer = nullptr

const Surface *startSurface = nullptr

const TrackingVolume *startVolume = nullptr

NavigatorStatistics statistics

const Surface *targetSurface = nullptr

class NeutralParticleHypothesis : public Acts::GenericParticleHypothesis<Neutral>

Specialized particle hypothesis for neutral particles.

Note

This serves as a factory for common neutral particles.

Public Functions

template<typename other_charge_t>
inline constexpr NeutralParticleHypothesis(const GenericParticleHypothesis<other_charge_t> &other)

inline NeutralParticleHypothesis(PdgParticle absPdg)

inline constexpr NeutralParticleHypothesis(PdgParticle absPdg, float mass)

Public Static Functions

static inline NeutralParticleHypothesis geantino()

static inline NeutralParticleHypothesis photon()

static inline NeutralParticleHypothesis pion0()

class NonNeutralCharge

Charge and momentum interpretation for arbitrarily charged but not neutral particles.

Public Functions

inline constexpr NonNeutralCharge(float absQ) noexcept

Construct with the magnitude of the input charge.

inline constexpr NonNeutralCharge(SinglyCharged) noexcept

inline constexpr float absQ() const noexcept

inline constexpr float extractCharge(double qOverP) const noexcept

inline constexpr double extractMomentum(double qOverP) const noexcept

inline constexpr double qOverP(double momentum, float signedQ) const noexcept

Friends

inline friend constexpr friend bool operator== (NonNeutralCharge lhs, NonNeutralCharge rhs) noexcept

Compare for equality.

class NonNeutralChargedParticleHypothesis : public Acts::GenericParticleHypothesis<NonNeutralCharge>

Specialized particle hypothesis for non-neutral particles.

Note

This serves as a factory for common non-neutral particles.

Public Functions

template<typename other_charge_t>
inline constexpr NonNeutralChargedParticleHypothesis(const GenericParticleHypothesis<other_charge_t> &other)

inline NonNeutralChargedParticleHypothesis(PdgParticle absPdg)

inline constexpr NonNeutralChargedParticleHypothesis(PdgParticle absPdg, float mass, NonNeutralCharge chargeType)

Public Static Functions

static inline NonNeutralChargedParticleHypothesis chargedGeantino()

static inline NonNeutralChargedParticleHypothesis chargedGeantino(float absQ)

static inline NonNeutralChargedParticleHypothesis electron()

static inline NonNeutralChargedParticleHypothesis kaon()

static inline NonNeutralChargedParticleHypothesis muon()

static inline NonNeutralChargedParticleHypothesis pion()

static inline NonNeutralChargedParticleHypothesis pionLike(float absQ)

static inline NonNeutralChargedParticleHypothesis proton()

class NullBField : public Acts::MagneticFieldProvider

Null bfield which returns 0 always.

Public Functions

NullBField() = default

Default constructor.

inline virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override

Retrieve magnetic field value at a given location.

Requires a cache object created through makeCache().

Note

The position is ignored and only kept as argument to provide a consistent interface with other magnetic field services.

Parameters:

• position – [in] global 3D position for the lookup

• cache – [inout] Field provider specific cache object

Returns:

magnetic field vector at given position

inline bool isInside(const Vector3&) const

check whether given 3D position is inside look-up domain

Note

The method will always return true for the null B-Field

Returns:

true if position is inside the defined look-up grid, otherwise false

inline virtual Acts::MagneticFieldProvider::Cache makeCache(const Acts::MagneticFieldContext &mctx) const override

Make an opaque cache for the magnetic field.

Instructs the specific implementation to generate a Cache instance for magnetic field lookup.

Parameters:

mctx – The magnetic field context to generate cache for

Returns:

Cache The opaque cache object

struct Cache

Public Functions

inline Cache(const MagneticFieldContext&)

constructor with context

class ParticleHypothesis : public Acts::GenericParticleHypothesis<AnyCharge>

Specialized particle hypothesis for any kind of charged particles.

Note

This serves as a factory for common particles with any kind of charge.

Public Functions

template<typename other_charge_t>
inline constexpr ParticleHypothesis(const GenericParticleHypothesis<other_charge_t> &other)

inline ParticleHypothesis(PdgParticle absPdg)

inline constexpr ParticleHypothesis(PdgParticle absPdg, float mass, AnyCharge chargeType)

Public Static Functions

static inline ParticleHypothesis chargedGeantino()

static inline ParticleHypothesis chargedGeantino(float absQ)

static inline ParticleHypothesis electron()

static inline ParticleHypothesis geantino()

static inline ParticleHypothesis kaon()

static inline ParticleHypothesis muon()

static inline ParticleHypothesis photon()

static inline ParticleHypothesis pion()

static inline ParticleHypothesis pion0()

static inline ParticleHypothesis pionLike(float absQ)

static inline ParticleHypothesis proton()

class PerigeeSurface : public Acts::LineSurface

Class describing the Line to which the Perigee refers to.

The Surface axis is fixed to be the z-axis of the Tracking frame. It inherits from StraingLineSurface.

Public Functions

virtual std::string name() const final

Return properly formatted class name for screen output */.

PerigeeSurface &operator=(const PerigeeSurface &other)

Assignment operator.

Parameters:

other – is the source surface to be assigned

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int ingoreSegments) const final

Return a Polyhedron for the surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• ingoreSegments – is an ignored parameter

Returns:

A list of vertices and a face/facett description of it

virtual SurfaceType type() const final

Return the surface type.

class PlanarBounds : public Acts::SurfaceBounds

common base class for all bounds that are in a local x/y cartesian frame

• simply introduced to avoid wrong bound assignments to surfaces

Subclassed by Acts::ConvexPolygonBoundsBase, Acts::DiamondBounds, Acts::EllipseBounds, Acts::RectangleBounds, Acts::TrapezoidBounds

Public Functions

virtual const RectangleBounds &boundingBox() const = 0

Bounding box parameters.

Returns:

rectangle bounds for a bounding box

virtual std::vector<Vector2> vertices(unsigned int quarterSegments = 2u) const = 0

Return the vertices.

Note

for planar bounds without curved segments quarterSegments is ignored

Parameters:

quarterSegments – is the number of segments used to describe curved segments in a quarter of the phi range. If it is 1, then only the extrema points in phi are inserted next to the segment corners.

Returns:

vector for vertices in 2D

class PlaneLayer : public virtual Acts::PlaneSurface, public Acts::Layer

Class to describe a planar detector layer for tracking, it inhertis from both, Layer base class and PlaneSurface class.

Public Functions

PlaneLayer() = delete

PlaneLayer(const PlaneLayer &pla) = delete

~PlaneLayer() override = default

PlaneLayer &operator=(const PlaneLayer&) = delete

virtual const PlaneSurface &surfaceRepresentation() const override

Transforms the layer into a Surface representation for extrapolation.

Returns:

returns a reference to a PlaneSurface

virtual PlaneSurface &surfaceRepresentation() override

Public Static Functions

static inline MutableLayerPtr create(const Transform3 &transform, std::shared_ptr<const PlanarBounds> pbounds, std::unique_ptr<SurfaceArray> surfaceArray = nullptr, double thickness = 0., std::unique_ptr<ApproachDescriptor> ad = nullptr, LayerType laytyp = Acts::active)

Factory for a shared plane layer.

Parameters:

• transform – which places the layer in the global frame

• pbounds – the planar bounds that define the layer dimensions

• surfaceArray – is the surface array that holds the sensitive surfaces

• thickness – is the thickness of the layer (normal direction to plane)

• ad – is the approach descriptor for describing the approach surface

• laytyp – is the layer type

Returns:

shared pointer to a PlaneLayer

class PlaneSurface : public Acts::RegularSurface

Class for a planaer in the TrackingGeometry.

The PlaneSurface extends the Surface class with the possibility to convert local to global positions (vice versa).

Subclassed by Acts::PlaneLayer

Public Functions

virtual const SurfaceBounds &bounds() const override

Return method for bounds object of this surfrace.

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Convert a global position to a local one this is the most generic interface, which is implemented by all surfaces.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• direction – is the direction of the local position (ignored for RegularSurface)

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const override

Global to local transformation.

Note

For planar surfaces the momentum direction is ignored in the global to local transformation

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position - considered to be on surface but not inside bounds (check is done)

• tolerance – optional tolerance within which a point is considered valid on surface

Returns:

a Result<Vector2> which can be !ok() if the operation fails

Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const = 0

Convert a global position to a local one.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const final

Straight line intersection.

mathematical motivation:

the equation of the plane is given by: \( \vec n \cdot \vec x = \vec n \cdot \vec p,\) where \( \vec n = (n_{x}, n_{y}, n_{z})\) denotes the normal vector of the plane, \( \vec p = (p_{x}, p_{y}, p_{z})\) one specific point on the plane and \( \vec x = (x,y,z) \) all possible points on the plane.

Given a line with:\( \vec l(u) = \vec l_{1} + u \cdot \vec v \)

,

the solution for

\( u \) can be written: \( u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}\) If the denominator is 0 then the line lies:

• either in the plane

• perpendicular to the normal of the plane

Note

expected to be normalized)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The start position of the intersection attempt

• direction – The direction of the intersection attempt, (

• boundaryTolerance – The boundary check directive

• tolerance – the tolerance used for the intersection

Returns:

the SurfaceMultiIntersection object

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const final

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const override

Local to global transformation.

Note

For planar surfaces the momentum direction is ignored in the local to global transformation

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

the global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

The global position by value

Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

This is the most generic interface, which is implemented by all surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction (ignored for RegularSurface)

Returns:

The global position by value

std::pair<std::shared_ptr<PlaneSurface>, bool> mergedWith(const PlaneSurface &other, AxisDirection direction, const Logger &logger = getDummyLogger()) const

Merge two plane surfaces into a single one.

Note

The surfaces need to be compatible, i.e. have bounds that align along merging direction, and have the same bound size along the non-merging direction

Note

The returned boolean is false if this is left or counter-clockwise of other, and true if not.

Parameters:

• other – The other plane surface to merge with

• direction – The direction: either AxisX or AxisY

• logger – The logger to use

Returns:

The merged plane surface and a boolean indicating if surfaces are reversed

virtual std::string name() const override

Return properly formatted class name for screen output.

Vector3 normal(const GeometryContext &gctx) const

Get the normal vector, independent of the location.

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

The normal vector

virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const final

Get the normal vector of this surface at a given local position.

return a Vector3 by value

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position is ignored

Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Calculate the normal vector of the surface This overload requires an on-surface local position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position where the normal vector is constructed

Returns:

normal vector by value

Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const final

Calculate the normal vector of the surface This overload is fully generic, fulfills the Surface interface and accepts a global position and a direction.

For RegularSurface this is equivalent to the normal overload, ignoring the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – is the global position where the normal vector is constructed

• direction – is the direction of the normal vector (ignored for RegularSurface)

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const final

Get the normal vector of this surface at a given global position.

Note

The position is required to be on-surface.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global positiono (for PlaneSurface this is ignored)

Returns:

The normal vector

Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the normal vector of the surface This overload accepts a global position.

Parameters:

• position – is the global position where the normal vector is constructed

• gctx – The current geometry context object, e.g. alignment

Returns:

normal vector by value

PlaneSurface &operator=(const PlaneSurface &other)

Assignment operator.

Parameters:

other – The source PlaneSurface for assignment

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const final

Method that calculates the correction due to incident angle.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position (ignored for PlaneSurface)

• direction – global 3D momentum direction (ignored for PlaneSurface)

Returns:

a double representing the scaling factor

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments) const override

Return a Polyhedron for the surfaces.

Note

for planar surfaces without curved segments quarterSegments is ignored

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – is the number of segments used to describe curved segments in a quarter of the phi range. If it is 1, then only the extrema points in phi are inserted next to the segment corners.

Returns:

A list of vertices and a face/facett description of it

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const final

The axis position is the position calculated for a certain axis type.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the axis direction of reference position request

Returns:

position that can be used for this axis

virtual SurfaceType type() const override

Return the surface type.

template<typename stepper_t, typename navigator_t = VoidNavigator>
class Propagator : public std::conditional_t<SupportsBoundParameters_v<stepper_t>, detail::BasePropagatorHelper<Propagator<stepper_t, VoidNavigator>>, detail::PropagatorStub>

Propagator for particles (optionally in a magnetic field)

The Propagator works with a state objects given at function call This state object contains the thread local state objects

• Navigator::state_type for object navigation and screen output

• Stepper::state_type state for the actual transport caching (pos,dir,field)

This Propagator class serves as high-level steering code for propagating track parameters. The actual implementation of the propagation has to be implemented in the stepper_t object, which has to provide the following:

• a function for performing a single propagation step

• a type mapping for: initial track parameter type -> type of final track parameters

• a type mapping for: (initial track parameter type and destination surface type) -> type of final track parameters

• a type mapping for: initial track parameter type -> type of internal state object

• a type mapping for: (initial track parameter type and destination surface type) -> type of internal state object

Template Parameters:

• stepper_t – Type of stepper implementation of the propagation

• naviagor_t – Type of the navigator (optional)

Public Types

template<typename parameters_t, typename actor_list_t>
using actor_list_t_result_t = typename result_type_helper<parameters_t, actor_list_t>::type

Short-hand type definition for propagation result derived from an action list.

Template Parameters:

• parameters_t – Type of the final track parameters

• actor_list_t – List of propagation action types

template<typename propagator_options_t, typename actor_list_t>
using actor_list_t_state_t = typename state_type_helper<propagator_options_t, actor_list_t>::type

Short-hand type definition for propagation state derived from an action list.

Template Parameters:

actor_list_t – List of propagation action types

using Navigator = navigator_t

Type of the navigator in use for public scope.

using NavigatorOptions = typename navigator_t::Options

using NavigatorState = typename navigator_t::State

Typedef the navigator state.

template<typename actor_list_t = ActorList<>>
using Options = PropagatorOptions<StepperOptions, NavigatorOptions, actor_list_t>

template<typename propagator_options_t, typename ...extension_state_t>
using State = PropagatorState<propagator_options_t, StepperState, NavigatorState, extension_state_t...>

using Stepper = stepper_t

Type of the stepper in use for public scope.

using StepperOptions = typename stepper_t::Options

using StepperState = typename Stepper::State

Type of state object used by the propagation implementation.

Public Functions

inline explicit Propagator(stepper_t stepper, navigator_t navigator = navigator_t(), std::shared_ptr<const Logger> _logger = getDefaultLogger("Propagator", Acts::Logging::INFO))

Constructor from implementation object.

Parameters:

• stepper – The stepper implementation is moved to a private member

• navigator – The navigator implementation, moved to a private member

• _logger – a logger instance

template<typename propagator_state_t, typename parameters_t, typename path_aborter_t = PathLimitReached>
Result<void> initialize(propagator_state_t &state, const parameters_t &start) const

Initialize the propagator state.

This function initializes the propagator state for a new propagation.

Template Parameters:

• propagator_state_t – Type of the propagator state object

• path_aborter_t – The path aborter type to be added

Parameters:

• state – [inout] The propagator state object

• start – [in] Initial track parameters to propagate

Returns:

Indication if the initialization was successful

template<typename propagator_state_t, typename propagator_options_t>
Result<actor_list_t_result_t<StepperCurvilinearTrackParameters, typename propagator_options_t::actor_list_type>> makeResult(propagator_state_t state, Result<void> result, const propagator_options_t &options, bool makeCurvilinear) const

Builds the propagator result object.

This function creates the propagator result object from the propagator state object. The result is passed to pipe a potential error from the propagation call. The options are used to determine the type of the result object. The makeCurvilinear flag is used to determine if the result should contain curvilinear track parameters.

Template Parameters:

• propagator_state_t – Type of the propagator state object

• propagator_options_t – Type of the propagator options

Parameters:

• state – [in] Propagator state object

• result – [in] Result of the propagation

• options – [in] Propagation options

• makeCurvilinear – [in] Produce curvilinear parameters at the end of the propagation

Returns:

Propagation result

template<typename propagator_state_t, typename propagator_options_t>
Result<actor_list_t_result_t<StepperBoundTrackParameters, typename propagator_options_t::actor_list_type>> makeResult(propagator_state_t state, Result<void> result, const Surface &target, const propagator_options_t &options) const

Builds the propagator result object.

This function creates the propagator result object from the propagator state object. The result is passed to pipe a potential error from the propagation call. The options are used to determine the type of the result object.

Template Parameters:

• propagator_state_t – Type of the propagator state object

• propagator_options_t – Type of the propagator options

Parameters:

• state – [in] Propagator state object

• result – [in] Result of the propagation

• target – [in] Target surface of to propagate to

• options – [in] Propagation options

Returns:

Propagation result

template<typename propagator_options_t, typename path_aborter_t = PathLimitReached>
auto makeState(const propagator_options_t &options) const

Builds the propagator state object.

This function creates the propagator state object from the initial track parameters and the propagation options.

Template Parameters:

• propagator_options_t – Type of the propagator options

• path_aborter_t – The path aborter type to be added

Parameters:

options – [in] Propagation options

Returns:

Propagator state object

template<typename propagator_options_t, typename target_aborter_t = SurfaceReached, typename path_aborter_t = PathLimitReached>
auto makeState(const Surface &target, const propagator_options_t &options) const

Builds the propagator state object.

This function creates the propagator state object from the initial track parameters, the target surface, and the propagation options.

Template Parameters:

• propagator_options_t – Type of the propagator options

• target_aborter_t – The target aborter type to be added

• path_aborter_t – The path aborter type to be added

Parameters:

• target – [in] Target surface of to propagate to

• options – [in] Propagation options

Returns:

Propagator state object

inline const navigator_t &navigator() const

template<typename parameters_t, typename propagator_options_t, typename path_aborter_t = PathLimitReached>
Result<actor_list_t_result_t<StepperCurvilinearTrackParameters, typename propagator_options_t::actor_list_type>> propagate(const parameters_t &start, const propagator_options_t &options, bool makeCurvilinear = true) const

Propagate track parameters.

This function performs the propagation of the track parameters using the internal stepper implementation, until at least one abort condition is fulfilled or the maximum number of steps/path length provided in the propagation options is reached.

Template Parameters:

• parameters_t – Type of initial track parameters to propagate

• propagator_options_t – Type of the propagator options

• path_aborter_t – The path aborter type to be added

Parameters:

• start – [in] initial track parameters to propagate

• options – [in] Propagation options, type Options<,>

• makeCurvilinear – [in] Produce curvilinear parameters at the end of the propagation

Returns:

Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)

template<typename parameters_t, typename propagator_options_t, typename target_aborter_t = SurfaceReached, typename path_aborter_t = PathLimitReached>
Result<actor_list_t_result_t<StepperBoundTrackParameters, typename propagator_options_t::actor_list_type>> propagate(const parameters_t &start, const Surface &target, const propagator_options_t &options) const

Propagate track parameters - User method.

This function performs the propagation of the track parameters according to the internal implementation object until at least one abort condition is fulfilled, the destination surface is hit or the maximum number of steps/path length as given in the propagation options is reached.

Template Parameters:

• parameters_t – Type of initial track parameters to propagate

• propagator_options_t – Type of the propagator options

• target_aborter_t – The target aborter type to be added

• path_aborter_t – The path aborter type to be added

Parameters:

• start – [in] Initial track parameters to propagate

• target – [in] Target surface of to propagate to

• options – [in] Propagation options

Returns:

Propagation result containing the propagation status, final track parameters, and output of actions (if they produce any)

template<typename propagator_state_t>
Result<void> propagate(propagator_state_t &state) const

Propagate track parameters.

This function performs the propagation of the track parameters according to the internal implementation object until at least one abort condition is fulfilled, the destination surface is hit or the maximum number of steps/path length as given in the propagation options is reached.

Note

Does not (yet) convert into the return_type of the propagation

Template Parameters:

propagator_state_t – Type of the propagator state with options

Parameters:

state – [inout] the propagator state object

Returns:

Propagation result

inline const stepper_t &stepper() const

template<typename BinningType>
class ProtoSurfaceMaterialT : public Acts::ISurfaceMaterial

Public Functions

ProtoSurfaceMaterialT() = default

Constructor without binningType - homogeneous material.

inline ProtoSurfaceMaterialT(const BinningType &binning, MappingType mappingType = MappingType::Default)

Constructor with BinningType.

Parameters:

• binning – a binning description for the material map binning

• mappingType – is the type of surface mapping associated to the surface

ProtoSurfaceMaterialT(const ProtoSurfaceMaterialT<BinningType> &smproxy) = default

Copy constructor.

Parameters:

smproxy – The source proxy

ProtoSurfaceMaterialT(ProtoSurfaceMaterialT<BinningType> &&smproxy) = default

Copy move constructor.

Parameters:

smproxy – The source proxy

~ProtoSurfaceMaterialT() override = default

Destructor.

inline const BinningType &binning() const

Return the BinUtility.

inline virtual const MaterialSlab &materialSlab(const Vector2&) const final

Return method for full material description of the Surface - from local coordinates.

Returns:

will return dummy material

inline virtual const MaterialSlab &materialSlab(const Vector3&) const final

Return method for full material description of the Surface - from the global coordinates.

Returns:

will return dummy material

ProtoSurfaceMaterialT<BinningType> &operator=(const ProtoSurfaceMaterialT<BinningType> &smproxy) = default

Assignment operator.

Parameters:

smproxy – The source proxy

ProtoSurfaceMaterialT<BinningType> &operator=(ProtoSurfaceMaterialT<BinningType> &&smproxy) = default

Assignment move operator.

Parameters:

smproxy – The source proxy

inline virtual ProtoSurfaceMaterialT<BinningType> &scale(double) final

Scale operation - dummy implementation.

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

Output Method for std::ostream, to be overloaded by child classes.

Parameters:

sl – is the output stream

class RadialBounds : public Acts::DiscBounds

Class to describe the bounds for a planar DiscSurface.

By providing an argument for hphisec, the bounds can be restricted to a phi-range around the center position.

Public Types

enum BoundValues

Values:

enumerator eMinR

enumerator eMaxR

enumerator eHalfPhiSector

enumerator eAveragePhi

enumerator eSize

Public Functions

inline RadialBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor from array values.

Parameters:

values – The bound values

inline RadialBounds(double minR, double maxR, double halfPhi = std::numbers::pi, double avgPhi = 0.) noexcept(false)

Constructor for full disc of symmetric disc around phi=0.

Parameters:

• minR – The inner radius (0 for full disc)

• maxR – The outer radius

• halfPhi – The half opening angle (Pi for full angular coverage)

• avgPhi – The average phi for the disc/ring sector

inline virtual double binningValuePhi() const final

Return a reference radius for binning.

inline virtual double binningValueR() const final

Return a reference radius for binning.

inline virtual bool coversFullAzimuth() const final

Returns true for full phi coverage.

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) const final

For disc surfaces the local position in (r,phi) is checked.

Parameters:

• lposition – local position to be checked

• boundaryTolerance – boundary check directive

Returns:

is a boolean indicating the operation success

inline virtual bool insideRadialBounds(double R, double tolerance = 0.) const final

Checks if this is inside the radial coverage given the a tolerance.

inline virtual double rMax() const final

Return method for outer Radius.

inline virtual double rMin() const final

Return method for inner Radius.

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

Outstream operator.

Parameters:

sl – is the ostream to be dumped into

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class RectangleBounds : public Acts::PlanarBounds

Bounds for a rectangular, planar surface - it can be used to for rectangles that are symmetrically centered around (0./0.) and for generic shifted rectangles

Public Types

enum BoundValues

Values:

enumerator eMinX

enumerator eMinY

enumerator eMaxX

enumerator eMaxY

enumerator eSize

Public Functions

inline RectangleBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from fixed size array - generic.

Parameters:

values – The parameter values

inline RectangleBounds(const Vector2 &min, const Vector2 &max) noexcept(false)

Constructor - from min/max - generic.

Parameters:

• min – The left bottom corner

• max – The right top corning

inline RectangleBounds(double halfX, double halfY) noexcept(false)

Constructor with halflength in x and y - symmetric.

Parameters:

• halfX – halflength in X

• halfY – halflength in Y

virtual const RectangleBounds &boundingBox() const final

Bounding box parameters.

Returns:

rectangle bounds for a bounding box

double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

inline double halfLengthX() const

Access to the half length in X.

inline double halfLengthY() const

Access to the half length in Y.

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) 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)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

inline const Vector2 &max() const

Get the max vertex defining the bounds.

Returns:

The max vertex

inline const Vector2 &min() const

Get the min vertex defining the bounds.

Returns:

The min vertex

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

Output Method for std::ostream.

Parameters:

sl – is the ostream for the dump

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.

Returns:

of the stored values for this SurfaceBounds object

virtual std::vector<Vector2> vertices(unsigned int quarterSegments = 0u) const final

Return the vertices.

Note

the number of segments is ignored in this representation

Parameters:

quarterSegments – is the number of segments used to describe curved segments in a quarter of the phi range.

Returns:

vector for vertices in 2D

class RegularSurface : public Acts::Surface

A physical surface which does not depend on the direction you look at it from.

As such it narrows the interface of Surface and allows inspection without providing a global position and direction.

Subclassed by Acts::ConeSurface, Acts::CylinderSurface, Acts::DiscSurface, Acts::PlaneSurface

Public Functions

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const final

Convert a global position to a local one this is the most generic interface, which is implemented by all surfaces.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• direction – is the direction of the local position (ignored for RegularSurface)

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, double tolerance = s_onSurfaceTolerance) const = 0

Convert a global position to a local one.

Note

The position is required to be on-surface, which is indicated by the Result return value.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position to be converted

• tolerance – is the tolerance for the on-surface check

Returns:

Result type containing local position by value

bool isOnSurface(const GeometryContext &gctx, const Vector3 &position, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None(), double tolerance = s_onSurfaceTolerance) const

The geometric onSurface method.

Geometrical check whether position is on Surface

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global position to be evaludated

• boundaryTolerance – BoundaryTolerance directive for this onSurface check

• tolerance – optional tolerance within which a point is considered on surface

Returns:

boolean indication if operation was successful

bool isOnSurface(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None(), double tolerance = s_onSurfaceTolerance) const

The geometric onSurface method.

Geometrical check whether position is on Surface

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global position to be evaludated

• direction – global momentum direction (required for line-type surfaces)

• boundaryTolerance – BoundaryTolerance directive for this onSurface check

• tolerance – optional tolerance within which a point is considered on surface

Returns:

boolean indication if operation was successful

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Local to global transformation.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

Returns:

The global position by value

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const final

Local to global transformation.

This is the most generic interface, which is implemented by all surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction (ignored for RegularSurface)

Returns:

The global position by value

virtual Vector3 normal(const GeometryContext &gctx, const Vector2 &lposition) const = 0

Calculate the normal vector of the surface This overload requires an on-surface local position.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – is the local position where the normal vector is constructed

Returns:

normal vector by value

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const final

Calculate the normal vector of the surface This overload is fully generic, fulfills the Surface interface and accepts a global position and a direction.

For RegularSurface this is equivalent to the normal overload, ignoring the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – is the global position where the normal vector is constructed

• direction – is the direction of the normal vector (ignored for RegularSurface)

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the normal vector of the surface This overload accepts a global position.

Parameters:

• position – is the global position where the normal vector is constructed

• gctx – The current geometry context object, e.g. alignment

Returns:

normal vector by value

Surface(const DetectorElementBase &detelement)

Constructor from DetectorElementBase: Element proxy.

Parameters:

detelement – Detector element which is represented by this surface

Surface(const GeometryContext &gctx, const Surface &other, const Transform3 &shift)

Copy constructor with optional shift.

Note

copy construction invalidates the association to detector element and layer

Parameters:

• gctx – The current geometry context object, e.g. alignment

• other – Source surface for copy

• shift – Additional transform applied as: shift * transform

Surface(const Surface &other)

Copy constructor.

Note

copy construction invalidates the association to detector element and layer

Parameters:

other – Source surface for copy.

Surface(const Transform3 &transform = Transform3::Identity())

Constructor with Transform3 as a shared object.

Note

also acts as default constructor

Parameters:

transform – Transform3 positions the surface in 3D global space

template<typename T, typename E = std::error_code>
class Result

Class which encapsulates either a valid result, or an error.

Template Parameters:

• T – The valid result value

• E – The error, defaults to std::error_code

Public Types

using ErrorType = E

using ValueType = T

Public Functions

Result() = delete

Default construction is disallowed.

Result(const Result<T, E> &other) = delete

Copy construction is disallowed.

inline Result(Result<T, E> &&other) noexcept

Move construction is allowed.

template<typename T2> inline  Result (T2 value) noexcept requires(!std

Constructor from arbitrary value This constructor allows construction from any value.

This constructor is only enabled if T and E are unambiguous, meaning they cannot be implicitly converted and there is T cannot be constructed from E and vice-versa. This means that when this is invoked, the value can be propagated to the underlying variant, and the assignment will be correct, and error will be an error, and a value will be a value.

Note

If T and E are ambiguous, use the success and failure static factory methods.

Template Parameters:

T2 – Type of the potential assignment

Parameters:

value – The potential value, could be an actual valid value or an error.

inline E error() && noexcept

Returns the error by-value.

Note

If res.ok() this method will abort (noexcept)

Returns:

The error

inline E &error() & noexcept

Returns a reference to the error stored in the result.

Note

If res.ok() this method will abort (noexcept)

Returns:

Reference to the error

inline const E &error() const & noexcept

Returns a reference to the error stored in the result.

Note

If res.ok() this method will abort (noexcept)

Returns:

Reference to the error

inline bool ok() const noexcept

Checks whether this result contains a valid value, and no error.

Returns:

bool Whether result contains an error or not.

inline const T &operator*() const noexcept

Returns a reference into the variant to the valid value.

Note

If !res.ok(), this method will abort (noexcept)

Returns:

Reference to value stored in the variant.

inline T &operator*() noexcept

Returns a reference into the variant to the valid value.

Note

If !res.ok(), this method will abort (noexcept)

Returns:

Reference to value stored in the variant.

inline const T *operator->() const noexcept

Allows to access members of the stored object with res->foo similar to std::optional.

Note

If !res.ok(), this method will abort (noexcept)

Returns:

Pointer to value stored in the variant.

inline T *operator->() noexcept

Allows to access members of the stored object with res->foo similar to std::optional.

Note

If !res.ok(), this method will abort (noexcept)

Returns:

Pointer to value stored in the variant.

Result<T, E> &operator=(const Result<T, E> &other) = delete

Assignment is disallowed.

inline Result<T, E> &operator=(Result<T, E> &&other) noexcept

Move assignment is allowed.

Parameters:

other – The other result instance, rvalue reference

Returns:

The assigned instance

template<typename T2> inline Result< T, E > & operator= (T2 value) noexcept requires(!std

Assignment operator from arbitrary value This operator allows construction from any value.

The same rules as for the Result(T2 value) constructor apply.

Template Parameters:

T2 – Type of the potential assignment

Parameters:

value – The potential value, could be an actual valid value or an error.

Returns:

The assigned instance

inline T &value() &

Retrieves the valid value from the result object.

Note

This is the lvalue version, returns a reference to the value

Returns:

The valid value as a reference

inline T value() &&

Retrieves the valid value from the result object.

Note

This is the rvalue version, returns the value by-value and moves out of the variant.

Returns:

The valid value by value, moved out of the variant.

inline const T &value() const &

Retrieves the valid value from the result object.

Note

This is the lvalue version, returns a reference to the value

Returns:

The valid value as a reference

template<typename U> inline T value_or (U &&v) &&requires(std

Retrieves the valid value from the result object, or returns a default value if no valid value exists.

Note

This is the rvalue version which moves the value out.

Note

This function always returns by value.

Parameters:

v – [in] The default value to use if no valid value exists.

Returns:

Either the valid value, or the given substitute.

template<typename U> inline std::conditional_t< std::is_reference_v< U >, const T &, T > value_or (U &&v) const &requires(std

Retrieves the valid value from the result object, or returns a default value if no valid value exists.

Note

This is the lvalue version.

Note

This function always returns by value.

Parameters:

v – [in] The default value to use if no valid value exists.

Returns:

Either the valid value, or the given substitute.

Public Members

template<typename C> auto transform(C &&callable) const &requires std void checkValueAccess () const

Transforms the value contained in this result.

Applying a function f to a valid value x returns f(x), while applying f to an invalid value returns another invalid value.

Applying a function f to a valid value x returns f(x), while applying f to an invalid value returns another invalid value.

This function takes a function f and, if this result contains a valid value x, returns f(x). If the type of x is T, then f is expected to accept type T and return Result<U>. In this case, transform would return the unhelpful type Result<Result<U>>, so and_then strips away the outer layer to return Result<U>. If the value is invalid, this returns an invalid value in Result<U>.

This function takes a function f and, if this result contains a valid value x, returns f(x). If the type of x is T, then f is expected to accept type T and return Result<U>. In this case, transform would return the unhelpful type Result<Result<U>>, so and_then strips away the outer layer to return Result<U>. If the value is invalid, this returns an invalid value in Result<U>.

Note

This is the lvalue version.

Note

This functions is fmap on the functor in A of Result<A, E>.

Note

This is the rvalue version.

Note

This functions is fmap on the functor in A of Result<A, E>.

Note

This is the lvalue version.

Note

This functions is >>= on the functor in A of Result<A, E>.

Note

This is the rvalue version.

Note

This functions is >>= on the functor in A of Result<A, E>.

Param callable:

[in] The transformation function to apply.

Return:

The modified valid value if exists, or an error otherwise. Transforms the value contained in this result.

Param callable:

[in] The transformation function to apply.

Return:

The modified valid value if exists, or an error otherwise. Bind a function to this result monadically.

Param callable:

[in] The transformation function to apply.

Return:

The modified valid value if exists, or an error otherwise. Bind a function to this result monadically.

Param callable:

[in] The transformation function to apply.

Return:

The modified valid value if exists, or an error otherwise.

Public Static Functions

static inline Result<T, E> failure(E error)

Static helper factory which forces assignment as an error.

Parameters:

error – The error to assign. Will not be converted to T.

Returns:

Initialized result object

static inline Result<T, E> success(T value)

Static helper factory which forces assignment as valid value.

Parameters:

value – The valid value to assign. Will not be converted to E.

Returns:

Initialized result object

template<typename external_spacepoint_t>
class SeedFilter

Filter seeds at various stages with the currently available information.

Public Functions

SeedFilter() = delete

SeedFilter(const SeedFilter<external_spacepoint_t>&) = delete

SeedFilter(const SeedFilterConfig &config, IExperimentCuts<external_spacepoint_t> *expCuts = nullptr)

SeedFilter(const SeedFilterConfig &config, std::unique_ptr<const Acts::Logger> logger, IExperimentCuts<external_spacepoint_t> *expCuts = nullptr)

SeedFilter(SeedFilter<external_spacepoint_t>&&) noexcept = default

~SeedFilter() = default

template<typename collection_t>
void filterSeeds_1SpFixed(Acts::SpacePointMutableData &mutableData, CandidatesForMiddleSp<const external_spacepoint_t> &candidates_collector, collection_t &outputCollection) const

Filter seeds once all seeds for one middle space point have been created.

Parameters:

• mutableData – Container for mutable variables used in the seeding

• candidates_collector – collection of seed candidates

• outputCollection – Output container for the seeds for all seeds with the same middle space point

template<typename collection_t>
void filterSeeds_1SpFixed(Acts::SpacePointMutableData &mutableData, std::vector<typename CandidatesForMiddleSp<const external_spacepoint_t>::value_type> &candidates, const std::size_t numQualitySeeds, collection_t &outputCollection) const

Filter seeds once all seeds for one middle space point have been created.

Parameters:

• mutableData – Container for mutable variables used in the seeding

• candidates – collection of seed candidates

• numQualitySeeds – number of high quality seeds in seed confirmation

• outputCollection – Output container for the seeds for all seeds with the same middle space point

void filterSeeds_2SpFixed(const Acts::SpacePointMutableData &mutableData, const external_spacepoint_t &bottomSP, const external_spacepoint_t &middleSP, const std::vector<const external_spacepoint_t*> &topSpVec, const std::vector<float> &invHelixDiameterVec, const std::vector<float> &impactParametersVec, SeedFilterState &seedFilterState, CandidatesForMiddleSp<const external_spacepoint_t> &candidates_collector) const

Create Seeds for the all seeds with the same bottom and middle space point and discard all others.

Parameters:

• mutableData – Container for mutable variables used in the seeding

• bottomSP – fixed bottom space point

• middleSP – fixed middle space point

• topSpVec – vector containing all space points that may be compatible with both bottom and middle space point

• invHelixDiameterVec – vector containing 1/(2*r) values where r is the helix radius

• impactParametersVec – vector containing the impact parameters

• seedFilterState – holds quantities used in seed filter

• candidates_collector – container for the seed candidates

inline const IExperimentCuts<external_spacepoint_t> *getExperimentCuts() const

inline const SeedFilterConfig getSeedFilterConfig() const

SeedFilter &operator=(const SeedFilter<external_spacepoint_t>&) = delete

SeedFilter &operator=(SeedFilter<external_spacepoint_t>&&) noexcept = default

class SinglyChargedParticleHypothesis : public Acts::GenericParticleHypothesis<SinglyCharged>

Specialized particle hypothesis for singly charged particles.

Note

This serves as a factory for common singly charge particles.

Public Functions

template<typename other_charge_t>
inline constexpr SinglyChargedParticleHypothesis(const GenericParticleHypothesis<other_charge_t> &other)

inline SinglyChargedParticleHypothesis(PdgParticle absPdg)

inline constexpr SinglyChargedParticleHypothesis(PdgParticle absPdg, float mass)

Public Static Functions

static inline SinglyChargedParticleHypothesis chargedGeantino()

static inline SinglyChargedParticleHypothesis electron()

static inline SinglyChargedParticleHypothesis kaon()

static inline SinglyChargedParticleHypothesis muon()

static inline SinglyChargedParticleHypothesis pion()

static inline SinglyChargedParticleHypothesis proton()

class SolenoidBField : public Acts::MagneticFieldProvider

Implements a multi-coil solenoid magnetic field.

On every call, the field is evaluated at that exact position. The field has radially symmetry, the field vectors point in +z direction. The config exposes a target field value in the center. This value is used to empirically determine a scale factor which reproduces this field value in the center.

E_1(k^2) = complete elliptic integral of the 1st kind E_2(k^2) = complete elliptic integral of the 2nd kind

E_1(k^2) and E_2(k^2) are usually indicated as K(k^2) and E(k^2) in literature, respectively _ 2 / pi / 2 2 2 - 1 / 2 E (k ) = | ( 1 - k sin {theta} ) dtheta 1 _/ 0

        _          ____________________

2 / pi / 2| / 2 2 E (k ) = | |/ 1 - k sin {theta} dtheta 2 _/ 0

k^2 = is a function of the point (r, z) and of the radius of the coil R

2 4Rr k = ————&#8212; 2 2 (R + r) + z Using these, you can evaluate the two components B_r and B_z of the magnetic field: _ _ mu I | / 2 \ | 0 kz | |2 - k | 2 2 | B (r, z) = –&#8212; —&#8212; | |—-&#8212;|E (k ) - E (k ) | r 4pi ___ | | 2| 2 1 | | / 3 |_ \2 - 2k / _| |/ Rr

 _                                       _

mu I | / 2 \ | 0 k | | (R + r)k - 2r | 2 2 | B (r,z) = –&#8212; -&#8212; | | ———–&#8212; | E (k ) + E (k ) | z 4pi __ | | 2 | 2 1 | |/Rr |_ \ 2r(1 - k ) / _|

Public Functions

SolenoidBField(Config config)

the constructor with a shared pointer

Note

since it is a shared field, we enforce it to be const

Template Parameters:

bField – is the shared BField to be stored

Vector2 getField(const Vector2 &position) const

Retrieve magnetic field value in local (r,z) coordinates.

Parameters:

position – [in] local 2D position

Vector3 getField(const Vector3 &position) const

Get the B field at a position.

Parameters:

position – The position to query at

virtual Result<Vector3> getField(const Vector3 &position, MagneticFieldProvider::Cache &cache) const override

Retrieve magnetic field value at a given location.

Requires a cache object created through makeCache().

Parameters:

• position – [in] global 3D position for the lookup

• cache – [inout] Field provider specific cache object

Returns:

magnetic field vector at given position

virtual MagneticFieldProvider::Cache makeCache(const MagneticFieldContext &mctx) const override

Make an opaque cache for the magnetic field.

Instructs the specific implementation to generate a Cache instance for magnetic field lookup.

Parameters:

mctx – The magnetic field context to generate cache for

Returns:

Cache The opaque cache object

struct Cache

Public Functions

inline Cache(const MagneticFieldContext&)

Constructor with magnetic field context.

struct Config

Config struct for the SolenoidBfield.

Public Members

double bMagCenter

The target magnetic field strength at the center.

This will be used to scale coefficients

double length

Extent of the solenoid in z.

It goes from -length/2 to +length/2 by convention

std::size_t nCoils

The number of coils that make up the solenoid.

double radius

Radius at which the coils are located.

class SourceLink

Public Functions

SourceLink(const SourceLink &other) = default

SourceLink(SourceLink &&other) = default

template<typename T> inline explicit  SourceLink (T &&upstream) requires(!std

Constructor from concrete source link.

Template Parameters:

T – The source link type

Parameters:

upstream – The upstream source link to store

template<typename T>
inline T &get()

Concrete source link class getter.

Template Parameters:

T – The source link type to retrieve

Returns:

Reference to the stored source link

template<typename T>
inline const T &get() const

Concrete source link class getter, const version.

Template Parameters:

T – The source link type to retrieve

Returns:

Const reference to the stored source link

SourceLink &operator=(const SourceLink &other) = default

SourceLink &operator=(SourceLink &&other) = default

class StraightLineStepper

straight line stepper based on Surface intersection

The straight line stepper is a simple navigation stepper to be used to navigate through the tracking geometry. It can be used for simple material mapping, navigation validation

Public Types

using BField = NullBField

using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>

using Covariance = BoundSquareMatrix

using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>

using Jacobian = BoundMatrix

Public Functions

inline double absoluteMomentum(const State &state) const

Absolute momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Create and return the bound state at the current position.

It does not check if the transported state is at the surface, this needs to be guaranteed by the propagator

Parameters:

• state – [in] State that will be presented as BoundState

• surface – [in] The surface to which we bind the state

• transportCov – [in] Flag steering covariance transport

• freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound

Returns:

A bound state:

• the parameters at the surface

• the stepwise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline double charge(const State &state) const

Charge access.

Parameters:

state – [in] The stepping state (thread-local cache)

CurvilinearState curvilinearState(State &state, bool transportCov = true) const

Create and return a curvilinear state at the current position.

This creates a curvilinear state.

Parameters:

• state – [in] State that will be presented as CurvilinearState

• transportCov – [in] Flag steering covariance transport

Returns:

A curvilinear state:

• the curvilinear parameters at given position

• the stepweise jacobian towards it (from last bound)

• and the path length (from start - for ordering)

inline Vector3 direction(const State &state) const

Momentum direction accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Result<Vector3> getField(State&, const Vector3&) const

Get the field for the stepping, this gives back a zero field.

inline double getStepSize(const State &state, ConstrainedStep::Type stype) const

Get the step size.

Parameters:

• state – [in] The stepping state (thread-local cache)

• stype – [in] The step size type to be returned

void initialize(State &state, const BoundTrackParameters &par) const

void initialize(State &state, const BoundVector &boundParams, const std::optional<BoundMatrix> &cov, ParticleHypothesis particleHypothesis, const Surface &surface) const

State makeState(const Options &options) const

inline Vector3 momentum(const State &state) const

Momentum accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline std::string outputStepSize(const State &state) const

Output the Step Size - single component.

Parameters:

state – [in,out] The stepping state (thread-local cache)

inline const ParticleHypothesis &particleHypothesis(const State &state) const

Particle hypothesis.

Parameters:

state – [in] The stepping state (thread-local cache)

inline Vector3 position(const State &state) const

Global particle position accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline bool prepareCurvilinearState(State &state) const

If necessary fill additional members needed for curvilinearState.

Compute path length derivatives in case they have not been computed yet, which is the case if no step has been executed yet.

Parameters:

state – [inout] The stepping state (thread-local cache)

Returns:

true if nothing is missing after this call, false otherwise.

inline double qOverP(const State &state) const

QoP direction accessor.

Parameters:

state – [in] The stepping state (thread-local cache)

inline void releaseStepSize(State &state, ConstrainedStep::Type stype) const

Release the Step size.

Parameters:

• state – [inout] The stepping state (thread-local cache)

• stype – [in] The step size type to be released

inline Result<double> step(State &state, Direction propDir, const IVolumeMaterial *material) const

Perform a straight line propagation step.

Note

The state contains the desired step size. It can be negative during backwards track propagation.

Parameters:

• state – [inout] State of the stepper

• propDir – is the direction of propagation

• material – is the optional volume material we are stepping through.

Returns:

the result of the step

inline double time(const State &state) const

Time access.

Parameters:

state – [in] The stepping state (thread-local cache)

void transportCovarianceToBound(State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection = FreeToBoundCorrection(false)) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state - for the moment a dummy method.

Note

no check is done if the position is actually on the surface

Template Parameters:

surface_t – the surface type - ignored here

Parameters:

• state – [inout] The stepper state

• surface – [in] is the surface to which the covariance is forwarded to

• freeToBoundCorrection – [in] Correction for non-linearity effect during transform from free to bound

void transportCovarianceToCurvilinear(State &state) const

Method for on-demand transport of the covariance to a new curvilinear frame at current position, or direction of the state - for the moment a dummy method.

Parameters:

state – [inout] State of the stepper

void update(State &state, const FreeVector &freeParams, const BoundVector &boundParams, const Covariance &covariance, const Surface &surface) const

Method to update a stepper state to the some parameters.

Parameters:

• state – [inout] State object that will be updated

• freeParams – [in] Free parameters that will be written into state

• boundParams – [in] Corresponding bound parameters used to update jacToGlobal in state

• covariance – [in] Covariance that will be written into state

• surface – [in] The surface used to update the jacToGlobal

void update(State &state, const Vector3 &uposition, const Vector3 &udirection, double qop, double time) const

Method to update the stepper state.

Parameters:

• state – [inout] State object that will be updated

• uposition – [in] the updated position

• udirection – [in] the updated direction

• qop – [in] the updated qop value

• time – [in] the updated time value

template<typename object_intersection_t>
inline void updateStepSize(State &state, const object_intersection_t &oIntersection, Direction direction, ConstrainedStep::Type stype) const

Update step size.

It checks the status to the reference surface & updates the step size accordingly

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• oIntersection – [in] The ObjectIntersection to layer, boundary, etc

• direction – [in] The propagation direction

• stype – [in] The step size type to be set

inline void updateStepSize(State &state, double stepSize, ConstrainedStep::Type stype) const

Update step size - explicitly with a double.

Parameters:

• state – [in,out] The stepping state (thread-local cache)

• stepSize – [in] The step size value

• stype – [in] The step size type to be set

inline IntersectionStatus updateSurfaceStatus(State &state, const Surface &surface, std::uint8_t index, Direction navDir, const BoundaryTolerance &boundaryTolerance, double surfaceTolerance, ConstrainedStep::Type stype, const Logger &logger = getDummyLogger()) const

Update surface status.

This method intersects the provided surface and update the navigation step estimation accordingly (hence it changes the state). It also returns the status of the intersection to trigger onSurface in case the surface is reached.

Parameters:

• state – [inout] The stepping state (thread-local cache)

• surface – [in] The surface provided

• index – [in] The surface intersection index

• navDir – [in] The navigation direction

• boundaryTolerance – [in] The boundary check for this status update

• surfaceTolerance – [in] Surface tolerance used for intersection

• stype – [in] The step size type to be set

• logger – [in] A logger instance

struct Config

struct Options : public Acts::StepperPlainOptions

Public Functions

inline Options(const GeometryContext &gctx, const MagneticFieldContext &mctx)

inline void setPlainOptions(const StepperPlainOptions &options)

struct State

State for track parameter propagation.

Public Functions

inline explicit State(const Options &optionsIn)

Constructor from the initial bound track parameters.

Note

the covariance matrix is copied when needed

Parameters:

optionsIn – [in] The options for the stepper

Public Members

Covariance cov = Covariance::Zero()

bool covTransport = false

Boolean to indicate if you need covariance transport.

FreeVector derivative = FreeVector::Zero()

The propagation derivative.

Jacobian jacobian = Jacobian::Identity()

The full jacobian of the transport entire transport.

BoundToFreeMatrix jacToGlobal = BoundToFreeMatrix::Zero()

Jacobian from local to the global frame.

FreeMatrix jacTransport = FreeMatrix::Identity()

Pure transport jacobian part from runge kutta integration.

std::size_t nSteps = 0

Total number of performed steps.

std::size_t nStepTrials = 0

Totoal number of attempted steps.

Options options

FreeVector pars = FreeVector::Zero()

Internal free vector parameters.

ParticleHypothesis particleHypothesis = ParticleHypothesis::pion()

Particle hypothesis.

double pathAccumulated = 0.

accummulated path length state

double previousStepSize = 0.

StepperStatistics statistics

Statistics of the stepper.

ConstrainedStep stepSize

adaptive step size of the runge-kutta integration

class StrawSurface : public Acts::LineSurface

Class for a StrawSurface in the TrackingGeometry to describe dirft tube and straw like detectors.

Public Functions

inline virtual std::string name() const final

Return properly formatted class name for screen output */.

StrawSurface &operator=(const StrawSurface &other)

Assignment operator.

Parameters:

other – is the source surface for copying

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments) const final

Return a Polyhedron for the surfaces.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – is the number of segments used to describe curved segments in a quarter of the phi range. If it is 1, then only the extrema points in phi are inserted next to the segment corners.

Returns:

A list of vertices and a face/facett description of it

inline virtual SurfaceType type() const final

Return the surface type.

class Surface : public virtual Acts::GeometryObject, public std::enable_shared_from_this<Surface>

Abstract Base Class for tracking surfaces.

The Surface class builds the core of the Acts Tracking Geometry. All other geometrical objects are either extending the surface or are built from it.

Surfaces are either owned by Detector elements or the Tracking Geometry, in which case they are not copied within the data model objects.

Subclassed by Acts::LineSurface, Acts::RegularSurface

Public Types

enum SurfaceType

This enumerator simplifies the persistency & calculations, by saving a dynamic_cast, e.g.

for persistency

Values:

enumerator Cone

enumerator Cylinder

enumerator Disc

enumerator Perigee

enumerator Plane

enumerator Straw

enumerator Curvilinear

enumerator Other

Public Functions

virtual ~Surface()

AlignmentToBoundMatrix alignmentToBoundDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const FreeVector &pathDerivative) const

The derivative of bound track parameters w.r.t.

alignment parameters of its reference surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)

Parameters:

• gctx – The current geometry context object, e.g. alignment change of alignment parameters

• position – global 3D position

• direction – global 3D momentum direction

• pathDerivative – is the derivative of free parameters w.r.t. path length

Returns:

Derivative of bound track parameters w.r.t. local frame alignment parameters

virtual AlignmentToPathMatrix alignmentToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

alignment parameters of the surface (i.e. local frame origin in global 3D Cartesian coordinates and its rotation represented with extrinsic Euler angles)

Note

Re-implementation is needed for surface whose intersection with track is not its local xy plane, e.g. LineSurface, CylinderSurface and ConeSurface

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. the alignment parameters

void assignDetectorElement(const DetectorElementBase &detelement)

Assign a detector element.

Parameters:

detelement – Detector element which is represented by this surface

void assignSurfaceMaterial(std::shared_ptr<const ISurfaceMaterial> material)

Assign the surface material description.

The material is usually derived in a complicated way and loaded from a framework given source. As various surfaces may share the same source this is provided by a shared pointer

Parameters:

material – Material description associated to this surface

const DetectorElementBase *associatedDetectorElement() const

Return method for the associated Detector Element.

Returns:

plain pointer to the DetectorElement, can be nullptr

const Layer *associatedLayer() const

Return method for the associated Layer in which the surface is embedded.

Returns:

Layer by plain pointer, can be nullptr

void associateLayer(const Layer &lay)

Set Associated Layer Many surfaces can be associated to a Layer, but it might not be known yet during construction of the layer, this can be set afterwards.

Parameters:

lay – the assignment Layer by reference

virtual const SurfaceBounds &bounds() const = 0

Return method for SurfaceBounds.

Returns:

SurfaceBounds by reference

virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Calculate the jacobian from local to global which the surface knows best, hence the calculation is done here.

Note

In principle, the input could also be a free parameters vector as it could be transformed to a bound parameters. But the transform might fail in case the parameters is not on surface. To avoid the check inside this function, it takes directly the bound parameters as input (then the check might be done where this function is called).

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Jacobian from local to global

virtual Vector3 center(const GeometryContext &gctx) const

Return method for the surface center by reference.

Note

the center is always recalculated in order to not keep a cache

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

center position by value

virtual FreeToBoundMatrix freeToBoundJacobian(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Calculate the jacobian from global to local which the surface knows best, hence the calculation is done here.

Note

It assumes the input free parameters is on surface, hence no onSurface check is done inside this function.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Jacobian from global to local

virtual FreeToPathMatrix freeToPathDerivative(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Calculate the derivative of path length at the geometry constraint or point-of-closest-approach w.r.t.

free parameters. The calculation is identical for all surfaces where the reference frame does not depend on the direction

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Derivative of path length w.r.t. free parameters

std::shared_ptr<Surface> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

std::shared_ptr<const Surface> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns:

The shared pointer

virtual Result<Vector2> globalToLocal(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, double tolerance = s_onSurfaceTolerance) const = 0

Global to local transformation Generalized global to local transformation for the surface types.

Since some surface types need the global momentum/direction to resolve sign ambiguity this is also provided

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position - considered to be on surface but not inside bounds (check is done)

• direction – global 3D momentum direction

• tolerance – optional tolerance within which a point is considered valid on surface

Returns:

a Result<Vector2> which can be !ok() if the operation fails

virtual bool insideBounds(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None()) const

The insideBounds method for local positions.

Parameters:

• lposition – The local position to check

• boundaryTolerance – BoundaryTolerance directive for this onSurface check

Returns:

boolean indication if operation was successful

virtual SurfaceMultiIntersection intersect(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::Infinite(), double tolerance = s_onSurfaceTolerance) const = 0

Straight line intersection schema from position/direction.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position to start from

• direction – The direction at start

• boundaryTolerance – the BoundaryTolerance

• tolerance – the tolerance used for the intersection

Returns:

SurfaceMultiIntersection object (contains intersection & surface)

bool isOnSurface(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const BoundaryTolerance &boundaryTolerance = BoundaryTolerance::None(), double tolerance = s_onSurfaceTolerance) const

The geometric onSurface method.

Geometrical check whether position is on Surface

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global position to be evaludated

• direction – global momentum direction (required for line-type surfaces)

• boundaryTolerance – BoundaryTolerance directive for this onSurface check

• tolerance – optional tolerance within which a point is considered on surface

Returns:

boolean indication if operation was successful

virtual ActsMatrix<2, 3> localCartesianToBoundLocalDerivative(const GeometryContext &gctx, const Vector3 &position) const = 0

Calculate the derivative of bound track parameters local position w.r.t.

position in local 3D Cartesian coordinates

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position of the parameters in global

Returns:

Derivative of bound local position w.r.t. position in local 3D cartesian coordinates

virtual Vector3 localToGlobal(const GeometryContext &gctx, const Vector2 &lposition, const Vector3 &direction) const = 0

Local to global transformation Generalized local to global transformation for the surface types.

Since some surface types need the global momentum/direction to resolve sign ambiguity this is also provided

Parameters:

• gctx – The current geometry context object, e.g. alignment

• lposition – local 2D position in specialized surface frame

• direction – global 3D momentum direction

Returns:

The global position by value

virtual std::string name() const = 0

Return properly formatted class name.

virtual Vector3 normal(const GeometryContext &gctx, const Vector3 &pos, const Vector3 &direction) const = 0

Return the surface normal at a given position and direction.

This method is fully generic, and valid for all surface types.

Note

For some surface types, the direction is ignored, but it is not safe to pass in a zero vector!

Parameters:

• gctx – The current geometry context object, e.g. alignment

• pos – The position at which to calculate the normal

• direction – The direction at which to calculate the normal

Returns:

The normal vector at the given position and direction

Surface &operator=(const Surface &other)

Assignment operator.

Note

copy construction invalidates the association to detector element and layer

Parameters:

other – Source surface for the assignment

virtual bool operator==(const Surface &other) const

Comparison (equality) operator The strategy for comparison is (a) first pointer comparison (b) then type comparison (c) then bounds comparison (d) then transform comparison.

Parameters:

other – source surface for the comparison

virtual double pathCorrection(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const = 0

Calucation of the path correction for incident.

Note

The position is either ignored, or it is coerced to be on the surface, depending on the surface type.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position

• direction – global 3D momentum direction

Returns:

Path correction with respect to the nominal incident.

virtual Polyhedron polyhedronRepresentation(const GeometryContext &gctx, unsigned int quarterSegments = 2u) const = 0

Return a Polyhedron for surface objects.

Note

In order to symmetrize the code between sectoral and closed cylinders in case of closed cylinders, both (-pi, pi) are given as separate vertices

Note

An internal surface transform can invalidate the extrema in the transformed space

Parameters:

• gctx – The current geometry context object, e.g. alignment

• quarterSegments – The number of segemtns to approximate a 0.5*pi sector, which represents a quarter of the full circle

Returns:

A list of vertices and a face/facett description of it

virtual Acts::RotationMatrix3 referenceFrame(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Return method for the reference frame This is the frame in which the covariance matrix is defined (specialized by all surfaces)

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – global 3D position - considered to be on surface but not inside bounds (check is done)

• direction – global 3D momentum direction (optionally ignored)

Returns:

RotationMatrix3 which defines the three axes of the measurement frame

const ISurfaceMaterial *surfaceMaterial() const

Return method for the associated Material to this surface.

Returns:

SurfaceMaterial as plain pointer, can be nullptr

const std::shared_ptr<const ISurfaceMaterial> &surfaceMaterialSharedPtr() const

Return method for the shared pointer to the associated Material.

Returns:

SurfaceMaterial as shared_pointer, can be nullptr

inline GeometryContextOstreamWrapper<Surface> toStream(const GeometryContext &gctx) const

Helper method for printing: the returned object captures the surface and the geometry context and will print the surface.

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

The wrapper object for printing

std::string toString(const GeometryContext &gctx) const

Output into a std::string.

Parameters:

gctx – The current geometry context object, e.g. alignment

virtual const Transform3 &transform(const GeometryContext &gctx) const

Return method for the surface Transform3 by reference In case a detector element is associated the surface transform is just forwarded to the detector element in order to keep the (mis-)alignment cache cetrally handled.

Parameters:

gctx – The current geometry context object, e.g. alignment

Returns:

the contextual transform

virtual SurfaceType type() const = 0

Return method for the Surface type to avoid dynamic casts.

void visualize(IVisualization3D &helper, const GeometryContext &gctx, const ViewConfig &viewConfig = s_viewSurface) const

Public Static Functions

template<class T, typename ...Args>
static inline std::shared_ptr<T> makeShared(Args&&... args)

Factory for producing memory managed instances of Surface.

Will forward all parameters and will attempt to find a suitable constructor.

Public Static Attributes

static std::array<std::string, SurfaceType::Other> s_surfaceTypeNames

Helper strings for screen output.

Friends

friend struct GeometryContextOstreamWrapper< Surface >

class SurfaceArray

Provides Surface binning in N dimensions.

Uses Grid under the hood to implement the storage and lookup Contains a lookup struct which talks to the Grid and performs utility actions. This struct needs to be initialised externally and passed to SurfaceArray on construction.

Public Functions

SurfaceArray(std::shared_ptr<const Surface> srf)

Constructor with a single surface.

Parameters:

srf – The one and only surface

SurfaceArray(std::unique_ptr<ISurfaceGridLookup> gridLookup, std::vector<std::shared_ptr<const Surface>> surfaces, const Transform3 &transform = Transform3::Identity())

Default constructor which takes a SurfaceLookup and a vector of surfaces.

Parameters:

• gridLookup – The grid storage. SurfaceArray does not fill it on its own

• surfaces – The input vector of surfaces. This is only for bookkeeping, so we can ask

• transform – Optional additional transform for this SurfaceArray

inline SurfaceVector &at(const Vector3 &position)

Get all surfaces in bin given by position.

Parameters:

position – the lookup position

Returns:

reference to SurfaceVector contained in bin at that position

inline const SurfaceVector &at(const Vector3 &position) const

Get all surfaces in bin given by position pos.

Parameters:

position – the lookup position

Returns:

const reference to SurfaceVector contained in bin at that position

inline SurfaceVector &at(std::size_t bin)

Get all surfaces in bin given by global bin index bin.

Parameters:

bin – the global bin index

Returns:

reference to SurfaceVector contained in bin

inline const SurfaceVector &at(std::size_t bin) const

Get all surfaces in bin given by global bin index.

Parameters:

bin – the global bin index

Returns:

const reference to SurfaceVector contained in bin

inline std::vector<AxisDirection> binningValues() const

The binning values described by this surface grid lookup They are in order of the axes.

inline std::vector<const IAxis*> getAxes() const

Get vector of axes spanning the grid as AnyAxis.

Note

The axes in the vector are copies. Only use for introspection and querying.

Returns:

vector of AnyAxis

inline Vector3 getBinCenter(std::size_t bin)

Get the center of the bin identified by global bin index bin.

Parameters:

bin – the global bin index

Returns:

Center position of the bin in global coordinates

inline bool isValidBin(std::size_t bin) const

Checks if global bin is valid.

Note

Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.

Parameters:

bin – the global bin index

Returns:

bool if the bin is valid

inline const SurfaceVector &neighbors(const Vector3 &position) const

Get all surfaces in bin at pos and its neighbors.

Note

The SurfaceVector will be combined. For technical reasons, the different bin content vectors have to be copied, so the resulting vector contains copies.

Parameters:

position – The position to lookup as nominal

Returns:

Merged SurfaceVector of neighbors and nominal

inline std::size_t size() const

Get the size of the underlying grid structure including under/overflow bins.

Returns:

the size

inline const SurfaceVector &surfaces() const

Get all surfaces attached to this SurfaceArray.

Note

This does not reflect the actual state of the grid. It only returns what was given in the constructor, without any checks if that is actually what’s in the grid.

Returns:

Reference to SurfaceVector containing all surfaces

std::ostream &toStream(const GeometryContext &gctx, std::ostream &sl) const

String representation of this SurfaceArray.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• sl – Output stream to write to

Returns:

the output stream given as sl

inline const Transform3 &transform() const

struct ISurfaceGridLookup

Base interface for all surface lookups.

Subclassed by Acts::SurfaceArray::SingleElementLookup, Acts::SurfaceArray::SurfaceGridLookup< Axes >

Public Functions

virtual ~ISurfaceGridLookup() = 0

Pure virtual destructor.

inline virtual std::vector<AxisDirection> binningValues() const

The binning values described by this surface grid lookup They are in order of the axes (optional) and empty for eingle lookups.

virtual std::size_t completeBinning(const GeometryContext &gctx, const SurfaceVector &surfaces) = 0

Attempts to fix sub-optimal binning by filling closest Surfaces into empty bin.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• surfaces – The surface pointers to fill

Returns:

number of bins that were filled

virtual std::size_t dimensions() const = 0

Get the number of dimensions of the grid.

Returns:

number of dimensions

virtual void fill(const GeometryContext &gctx, const SurfaceVector &surfaces) = 0

Fill provided surfaces into the contained Grid.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• surfaces – Input surface pointers

virtual std::vector<const IAxis*> getAxes() const = 0

Returns copies of the axes used in the grid as AnyAxis.

Note

This returns copies. Use for introspection and querying.

Returns:

The axes

virtual Vector3 getBinCenter(std::size_t bin) const = 0

Gets the center position of bin bin in global coordinates.

Parameters:

bin – the global bin index

Returns:

The bin center

virtual bool isValidBin(std::size_t bin) const = 0

Checks if global bin is valid.

Note

Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.

Parameters:

bin – the global bin index

Returns:

bool if the bin is valid

virtual const SurfaceVector &lookup(const Vector3 &position) const = 0

Performs lookup at pos and returns bin content as const reference.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin

virtual SurfaceVector &lookup(const Vector3 &position) = 0

Performs lookup at pos and returns bin content as reference.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin

virtual const SurfaceVector &lookup(std::size_t bin) const = 0

Performs lookup at global bin and returns bin content as const reference.

Parameters:

bin – Global lookup bin

Returns:

SurfaceVector at given bin

virtual SurfaceVector &lookup(std::size_t bin) = 0

Performs lookup at global bin and returns bin content as reference.

Parameters:

bin – Global lookup bin

Returns:

SurfaceVector at given bin

virtual const SurfaceVector &neighbors(const Vector3 &position) const = 0

Performs a lookup at pos, but returns neighbors as well.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin. Copy of all bins selected

virtual std::size_t size() const = 0

Returns the total size of the grid (including under/overflow bins)

Returns:

Size of the grid data structure

struct SingleElementLookup : public Acts::SurfaceArray::ISurfaceGridLookup

Lookup implementation which wraps one element and always returns this element when lookup is called.

Public Functions

inline SingleElementLookup(const SurfaceVector &elements)

Default constructor.

Parameters:

elements – the surfaces that are provided through a single lookup

inline SingleElementLookup(SurfaceVector::value_type element)

Default constructor.

Parameters:

element – the one and only element.

inline virtual std::size_t completeBinning(const GeometryContext&, const SurfaceVector&) override

Comply with concept and provide completeBinning method.

Note

Does nothing

inline virtual std::size_t dimensions() const override

Get the number of dimensions.

Returns:

always 0

inline virtual void fill(const GeometryContext&, const SurfaceVector&) override

Comply with concept and provide fill method.

Note

Does nothing

inline virtual std::vector<const IAxis*> getAxes() const override

Returns an empty vector of AnyAxis.

Returns:

empty vector

inline virtual Vector3 getBinCenter(std::size_t) const override

Gets the bin center, but always returns (0, 0, 0)

Returns:

(0, 0, 0)

inline virtual bool isValidBin(std::size_t) const override

Returns if the bin is valid (it is)

Returns:

always true

inline virtual const SurfaceVector &lookup(const Vector3&) const override

Lookup, always returns element.

Returns:

reference to vector containing only element

inline virtual SurfaceVector &lookup(const Vector3&) override

Lookup, always returns element.

Returns:

reference to vector containing only element

inline virtual const SurfaceVector &lookup(std::size_t) const override

Lookup, always returns element.

Returns:

reference to vector containing only element

inline virtual SurfaceVector &lookup(std::size_t) override

Lookup, always returns element.

Returns:

reference to vector containing only element

inline virtual const SurfaceVector &neighbors(const Vector3&) const override

Lookup, always returns element.

Returns:

reference to vector containing only element

inline virtual std::size_t size() const override

returns 1

Returns:

1

template<class ...Axes>
struct SurfaceGridLookup : public Acts::SurfaceArray::ISurfaceGridLookup

Lookup helper which encapsulates a Grid.

Template Parameters:

Axes – The axes used for the grid

Public Types

using Grid_t = Grid<SurfaceVector, Axes...>

using point_t = std::conditional_t<DIM == 1, std::array<double, 1>, ActsVector<DIM>>

Specifies the local coordinate type.

This resolves to ActsVector<DIM> for DIM > 1, else std::array<double, 1>

Public Functions

inline SurfaceGridLookup(std::function<point_t(const Vector3&)> globalToLocal, std::function<Vector3(const point_t&)> localToGlobal, std::tuple<Axes...> axes, std::vector<AxisDirection> bValues = {})

Default constructor.

Note

Signature of localToGlobal and globalToLocal depends on DIM. If DIM > 1, local coords are ActsVector<DIM> else std::array<double, 1>.

Parameters:

• globalToLocal – Callable that converts from global to local

• localToGlobal – Callable that converts from local to global

• axes – The axes to build the grid data structure.

• bValues – What the axes represent (optional)

inline virtual std::vector<AxisDirection> binningValues() const override

The binning values described by this surface grid lookup They are in order of the axes.

inline virtual std::size_t completeBinning(const GeometryContext &gctx, const SurfaceVector &surfaces) override

Attempts to fix sub-optimal binning by filling closest Surfaces into empty bins.

Note

This does not always do what you want.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• surfaces – The surface pointers to fill

Returns:

number of bins that were filled

inline virtual std::size_t dimensions() const override

Get the number of dimensions of the grid.

Returns:

number of dimensions

inline virtual void fill(const GeometryContext &gctx, const SurfaceVector &surfaces) override

Fill provided surfaces into the contained Grid.

This is done by iterating, accessing the referencePosition, lookup and append. Also populates the neighbor map by combining the filled bins of all bins around a given one.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• surfaces – Input surface pointers

inline virtual std::vector<const IAxis*> getAxes() const override

Returns copies of the axes used in the grid as AnyAxis.

Note

This returns copies. Use for introspection and querying.

Returns:

The axes

inline virtual Vector3 getBinCenter(std::size_t bin) const override

Gets the center position of bin bin in global coordinates.

Parameters:

bin – the global bin index

Returns:

The bin center

inline virtual bool isValidBin(std::size_t bin) const override

Checks if global bin is valid.

Note

Valid means that the index points to a bin which is not a under or overflow bin or out of range in any axis.

Parameters:

bin – the global bin index

Returns:

bool if the bin is valid

inline virtual const SurfaceVector &lookup(const Vector3 &position) const override

Performs lookup at pos and returns bin content as const reference.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin

inline virtual SurfaceVector &lookup(const Vector3 &position) override

Performs lookup at pos and returns bin content as reference.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin

inline virtual const SurfaceVector &lookup(std::size_t bin) const override

Performs lookup at global bin and returns bin content as const reference.

Parameters:

bin – Global lookup bin

Returns:

SurfaceVector at given bin

inline virtual SurfaceVector &lookup(std::size_t bin) override

Performs lookup at global bin and returns bin content as reference.

Parameters:

bin – Global lookup bin

Returns:

SurfaceVector at given bin

inline virtual const SurfaceVector &neighbors(const Vector3 &position) const override

Performs a lookup at pos, but returns neighbors as well.

Parameters:

position – Lookup position

Returns:

SurfaceVector at given bin. Copy of all bins selected

inline virtual std::size_t size() const override

Returns the total size of the grid (including under/overflow bins)

Returns:

Size of the grid data structure

Public Static Attributes

static constexpr std::size_t DIM = sizeof...(Axes)

class SurfaceArrayCreator

It is designed create sub surface arrays to be ordered on Surfaces.

Public Functions

inline SurfaceArrayCreator(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("SurfaceArrayCreator", Logging::INFO))

Constructor with explicit config.

Parameters:

• cfg – Explicit config struct

• logger – logging instance

inline SurfaceArrayCreator(std::unique_ptr<const Logger> logger = getDefaultLogger("SurfaceArrayCreator", Logging::INFO))

Constructor with default config.

Parameters:

logger – logging instance

virtual ~SurfaceArrayCreator() = default

Destructor.

inline void setLogger(std::unique_ptr<const Logger> logger)

Set logging instance.

Parameters:

logger – is the logging instance to be set

std::unique_ptr<Acts::SurfaceArray> surfaceArrayOnCylinder(const GeometryContext &gctx, std::vector<std::shared_ptr<const Surface>> surfaces, BinningType bTypePhi = equidistant, BinningType bTypeZ = equidistant, std::optional<ProtoLayer> protoLayerOpt = std::nullopt, const Transform3 &transform = Transform3::Identity()) const

SurfaceArrayCreator interface method.

• create an array in a cylinder, binned in phi, z when extremas and bin numbers are unknown - this method goes through the surfaces and finds out the needed information

Warning

This function requires the cylinder aligned with the z-axis

Parameters:

• surfaces – is the vector of pointers to sensitive surfaces to be ordered on the cylinder

• gctx – [in] The gometry context for this building call

• protoLayerOpt – The proto layer containing the layer size

• bTypePhi – the binning type in phi direction (equidistant/arbitrary)

• bTypeZ – the binning type in z direction (equidistant/arbitrary)

• transform – is the (optional) additional transform applied

Pre:

the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed

Returns:

a unique pointer a new SurfaceArray

std::unique_ptr<SurfaceArray> surfaceArrayOnCylinder(const GeometryContext &gctx, std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsPhi, std::size_t binsZ, std::optional<ProtoLayer> protoLayerOpt = std::nullopt, const Transform3 &transform = Transform3::Identity()) const

SurfaceArrayCreator interface method.

• create an array in a cylinder, binned in phi, z when extremas and bin numbers are known

Warning

This function requires the cylinder aligned with the z-axis

Parameters:

• surfaces – is the vector of pointers to sensitive surfaces to be ordered on the cylinder

• gctx – [in] The gometry context for this building call

• protoLayerOpt – The proto layer containing the layer size

• binsPhi – is the number of bins in phi for the surfaces

• binsZ – is the number of bin in Z for the surfaces

• transform – is the (optional) additional transform applied

Pre:

the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed

Returns:

a unique pointer to a new SurfaceArray

std::unique_ptr<Acts::SurfaceArray> surfaceArrayOnDisc(const GeometryContext &gctx, std::vector<std::shared_ptr<const Surface>> surfaces, BinningType bTypeR, BinningType bTypePhi, std::optional<ProtoLayer> protoLayerOpt = std::nullopt, const Transform3 &transform = Transform3::Identity()) const

SurfaceArrayCreator interface method.

• create an array in a cylinder, binned in phi, r when extremas and bin numbers are unknown - this method goes through the surfaces and finds out the needed information

Note

If there is more than on R-Ring, number of phi bins will be set to lowest number of surfaces of any R-ring. This ignores bTypePhi and produces equidistant binning in phi

Warning

This function requires the disc aligned with the z-axis

Parameters:

• surfaces – is the vector of pointers to sensitive surfaces to be ordered on the disc

• gctx – [in] The gometry context for this building call

• protoLayerOpt – The proto layer containing the layer size

• bTypeR – the binning type in r direction (equidistant/arbitrary)

• bTypePhi – the binning type in phi direction (equidistant/arbitrary)

• transform – is the (optional) additional transform applied

Pre:

the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed

Returns:

a unique pointer a new SurfaceArray

std::unique_ptr<SurfaceArray> surfaceArrayOnDisc(const GeometryContext &gctx, std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t binsR, std::size_t binsPhi, std::optional<ProtoLayer> protoLayerOpt = std::nullopt, const Transform3 &transform = Transform3::Identity()) const

SurfaceArrayCreator interface method.

• create an array on a disc, binned in r, phi when extremas and bin numbers are known

Warning

This function requires the disc aligned with the z-axis

Parameters:

• surfaces – is the vector of pointers to sensitive surfaces to be ordered on the disc

• gctx – [in] The gometry context for this building call

• protoLayerOpt – The proto layer containing the layer size

• binsPhi – is the number of bins in phi for the surfaces

• binsR – is the number of bin in R for the surfaces

• transform – is the (optional) additional transform applied

Pre:

the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed

Returns:

a unique pointer a new SurfaceArray

std::unique_ptr<SurfaceArray> surfaceArrayOnPlane(const GeometryContext &gctx, std::vector<std::shared_ptr<const Surface>> surfaces, std::size_t bins1, std::size_t bins2, AxisDirection aDir, std::optional<ProtoLayer> protoLayerOpt = std::nullopt, const Transform3 &transform = Transform3::Identity()) const

SurfaceArrayCreator interface method.

• create an array on a plane

Warning

This function requires the plane aligned with either the x-, y- or z-axis

Parameters:

• gctx – [in] The gometry context for this building call

• surfaces – [in] is the vector of pointers to sensitive surfaces to be ordered on the plane

• bins1 – [in] is the number of bins in the orthogonal direction to aDir

• bins2 – [in] is the number of bins in the orthogonal direction to aDir

• aDir – [in] Direction of the aligned surfaces

• protoLayerOpt – [in] Optional ProtoLayer instance

• transform – [in] is the (optional) additional transform applied

Pre:

the pointers to the sensitive surfaces in the surfaces vectors all need to be valid, since no check is performed

Returns:

a unique pointer a new SurfaceArray

Public Static Functions

static inline bool isSurfaceEquivalent(const GeometryContext &gctx, AxisDirection aDir, const Surface *a, const Surface *b)

Static check function for surface equivalent.

Parameters:

• gctx – [in] the geometry context for this check

• aDir – the axis direction for the binning

• a – first surface for checking

• b – second surface for checking

Friends

friend class Acts::SurfaceArray

friend struct Acts::Test::SurfaceArrayCreatorFixture

struct Config

Public Members

bool doPhiBinningOptimization = true

Optimize the binning in phi for disc layers.

Reduces the number of bins to the lowest number of non-equivalent phi surfaces of all r-bins. If false, this step is skipped.

SurfaceMatcher surfaceMatcher = SurfaceArrayCreator::isSurfaceEquivalent

Type-erased function which determines whether two surfaces are supposed to be considered equivalent in terms of the binning.

struct ProtoAxis

Public Functions

inline std::size_t getBin(AxisScalar x) const

Public Members

AxisDirection axisDir = AxisDirection::AxisX

std::vector<AxisScalar> binEdges

BinningType bType = BinningType::equidistant

AxisScalar max = 0

AxisScalar min = 0

std::size_t nBins = 0

class SurfaceBounds

Interface for surface bounds.

Surface bounds provide:

• inside() checks

• distance to boundary calculations

• the BoundsType and a set of parameters to simplify persistency

Subclassed by Acts::ConeBounds, Acts::CylinderBounds, Acts::DiscBounds, Acts::InfiniteBounds, Acts::LineBounds, Acts::PlanarBounds

Public Types

enum BoundsType

This is nested to the SurfaceBounds, as also VolumeBounds will have Bounds Type.

Values:

enumerator eCone

enumerator eCylinder

enumerator eDiamond

enumerator eDisc

enumerator eEllipse

enumerator eLine

enumerator eRectangle

enumerator eTrapezoid

enumerator eTriangle

enumerator eDiscTrapezoid

enumerator eConvexPolygon

enumerator eAnnulus

enumerator eBoundless

enumerator eOther

Public Functions

virtual ~SurfaceBounds() = default

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) const = 0

Inside check for the bounds object driven by the boundary check directive Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds Inside can be called without/with tolerances.

Parameters:

• lposition – Local position (assumed to be in right surface frame)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

virtual std::ostream &toStream(std::ostream &os) const = 0

Output Method for std::ostream, to be overloaded by child classes.

Parameters:

os – is the outstream in which the string dump is done

virtual BoundsType type() const = 0

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

virtual std::vector<double> values() const = 0

Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.

Returns:

of the stored values for this SurfaceBounds object

Friends

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

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

class TGeoDetectorElement : public Acts::DetectorElementBase

DetectorElement plugin for ROOT TGeo shapes.

Added possibility to hand over transformation matrix.

Subclassed by Acts::DD4hepDetectorElement

Public Types

using ContextType = GeometryContext

Broadcast the context type.

using Identifier = identifier_type

using identifier_diff = long long

using identifier_type = unsigned long long

Public Functions

TGeoDetectorElement(const Identifier &identifier, const TGeoNode &tGeoNode, const TGeoMatrix &tGeoMatrix = TGeoIdentity(), const std::string &axes = "XYZ", double scalor = 10., std::shared_ptr<const Acts::ISurfaceMaterial> material = nullptr)

Constructor.

Note

this constructor used auto-translation

Note

This parameter only needs to be set for plane modules

Note

In the translation from a 3D geometry (TGeo) which only knows tubes to a 2D geometry (Tracking geometry) a distinction if the module should be described as a cylinder or a disc surface needs to be done. Since this information can not be taken just from the geometry description (both can be described as TGeoTubeSeg), one needs to set the flag ‘isDisc’ in case a volume with shape TGeoTubeSeg should be translated to a disc surface. Per default it will be translated into a cylindrical surface.

Parameters:

• identifier – is the detector identifier

• tGeoNode – is the TGeoNode which should be represented

• tGeoMatrix – The Matrix to global (i.e. ACTS transform)

• axes – is the axis orientation with respect to the tracking frame it is a string of the three characters x, y and z (standing for the three axes) there is a distinction between capital and lower case characters :

  • capital -> positive orientation of the axis

  • lower case -> negative orientation of the axis example options are “XYZ” -> identical frame definition (default value) “YZX” -> node y axis is tracking x axis, etc. “XzY” -> negative node z axis is tracking y axis, etc.

• scalor – is the scale factor for unit conversion if needed

• material – Possible material of detector element

TGeoDetectorElement(const Identifier &identifier, const TGeoNode &tGeoNode, const Transform3 &tgTransform, const std::shared_ptr<const DiscBounds> &tgBounds, double tgThickness = 0.)

Constructor with pre-computed disk surface.

Note

this detector element constructor needs everything pre-computed.

Parameters:

• identifier – is the detector identifier

• tGeoNode – is the TGeoNode which should be represented

• tgTransform – the transform of this detector element

• tgBounds – the bounds of this surface

• tgThickness – the thickness of this detector element

TGeoDetectorElement(const Identifier &identifier, const TGeoNode &tGeoNode, const Transform3 &tgTransform, const std::shared_ptr<const PlanarBounds> &tgBounds, double tgThickness = 0.)

Constructor with pre-computed surface.

Note

this detector element constructor needs everything pre-computed.

Parameters:

• identifier – is the detector identifier

• tGeoNode – is the TGeoNode which should be represented

• tgTransform – the transform of this detector element

• tgBounds – the bounds of this surface

• tgThickness – the thickness of this detector element

~TGeoDetectorElement() override

inline Identifier identifier() const

inline virtual const Surface &surface() const override

Return surface associated with this detector element.

inline virtual Surface &surface() override

Return surface associated with this detector element.

Note

this is the non-const access

inline const TGeoNode &tgeoNode() const

Return the TGeoNode for back navigation.

inline virtual double thickness() const override

Returns the thickness of the module.

inline virtual const Transform3 &transform(const GeometryContext &gctx) const override

Return local to global transform associated with this identifier.

Parameters:

gctx – The current geometry context object, e.g. alignment

template<TrackContainerBackend track_container_t, CommonMultiTrajectoryBackend traj_t, template<typename> class holder_t = detail::RefHolder>
class TrackContainer

Track container interface class.

This type represents a collections of tracks. It uses a backend to store both the actual tracks and the associated track states.

Template Parameters:

• track_container_t – the track container backend

• traj_t – the track state container backend

• holder_t – ownership management class for the backend

TrackContainer construction

Constructors for the track container by using a set of backends (track + track state). The container can either take ownership of the backends or just hold references to them. This is driven by the holder_t template parameter, where you can also supply a custom holder type. Template deduction is used to try to guess the correct holder type.

inline TrackContainer(holder_t<track_container_t> container, holder_t<traj_t> traj)

Constructor from a track container backend and a track state container backend.

Parameters:

• container – the track container backend

• traj – the track state container backend

inline  TrackContainer (auto &container, auto &traj) requires(detail

Constructor from references to a track container backend and to a track state container backend.

Note

The track container will not assume ownership over the backends in this case. You need to ensure suitable lifetime

Parameters:

• container – the track container backend

• traj – the track state container backend

inline  TrackContainer (const auto &container, const auto &traj) requires(detail

Constructor from const references to a track container backend and to a track state container backend.

Note

The track container will not assume ownership over the backends in this case. You need to ensure suitable lifetime

Parameters:

• container – the track container backend

• traj – the track state container backend

TrackContainer track (proxy) access and manipulation

These methods allow accessing tracks, i.e. adding or retrieving a track proxy that points at a specific track in the container.

inline ConstTrackProxy getTrack(IndexType itrack) const

Get a const track proxy for a track index.

Parameters:

itrack – the track index in the container

Returns:

A const track proxy for the index

inline TrackProxy getTrack(IndexType itrack)
requires (!ReadOnly)

Get a mutable track proxy for a track index.

Note

Only available if the track container is not read-only

Parameters:

itrack – the track index in the container

Returns:

A mutable track proxy for the index

inline ConstTrackProxy at(IndexType itrack) const

Get a const track proxy for a track index.

Parameters:

itrack – the track index in the container

Returns:

A const track proxy for the index

inline TrackProxy at(IndexType itrack)
requires (!ReadOnly)

Get a mutable track proxy for a track index.

Note

Only available if the track container is not read-only

Parameters:

itrack – the track index in the container

Returns:

A mutable track proxy for the index

inline IndexType addTrack()
requires (!ReadOnly)

Add a track to the container.

Note this only creates the logical track and allocates memory. You can combine this with getTrack to obtain a track proxy

Note

Only available if the track container is not read-only

Returns:

the index to the newly added track

inline TrackProxy makeTrack()
requires (!ReadOnly)

Add a track to the container and return a track proxy to it This effectively calls addTrack and getTrack.

Note

Only available if the track container is not read-only

Returns:

a track proxy to the newly added track

inline void removeTrack(IndexType itrack)
requires (!ReadOnly)

Remove a track at index itrack from the container.

Note

Only available if the track container is not read-only

Note

This invalidates track proxies that point to tracks with larger indices than itrack!

Parameters:

itrack – The index of the track to remove

inline iterator begin()
requires (!ReadOnly)

Get a mutable iterator to the first track in the container.

Note

Only available if the track container is not read-only

Returns:

a mutable iterator to the first track

inline iterator end()
requires (!ReadOnly)

Get a past-the-end iterator for this container.

Note

Only available if the track container is not read-only

Returns:

a past-the-end iterator

inline const_iterator begin() const

Get an const iterator to the first track in the container.

Returns:

a const iterator to the first track

inline const_iterator end() const

Get a past-the-end iterator for this container.

Returns:

a past-the-end iterator

TrackContainer column management

TrackContainer can manage a set of common static columns, and dynamic columns that can be added at runtime.

This set of methods allows you to manage the dynamic columns.

template<typename T>
inline constexpr void addColumn(std::string_view key)
requires (!ReadOnly)

Add a dymanic column to the track container.

Note

Only available if the track container is not read-only

Parameters:

key – the name of the column to be added

inline constexpr bool hasColumn(const std::string &key) const

Check if this track container has a specific dynamic column.

Parameters:

key – the key to check for

inline constexpr bool hasColumn(HashedString key) const

Check if a this track container has a specific dynamic column.

Parameters:

key – the key to check for

template<typename other_track_container_t>
inline void ensureDynamicColumns(const other_track_container_t &other)
requires (!ReadOnly)

Helper function to make this track container match the dynamic columns of another one.

This will only work if the track container supports this source, and depends on the implementation details of the dynamic columns of the container

Note

Only available if the track container is not read-only

Template Parameters:

other_track_container_t – Type of the other track container

Parameters:

other – The other track container

TrackContainer backend access

These methods allow accessing the backend of the track container.

In most cases, this is not necessary for interacting with the container.

inline auto &container()
requires (!ReadOnly)

Get a mutable reference to the track container backend.

Note

Only available if the track container is not read-only

Returns:

a mutable reference to the backend

inline const auto &container() const

Get a const reference to the track container backend.

Returns:

a const reference to the backend

inline auto &trackStateContainer()
requires (!ReadOnly)

Get a mutable reference to the track state container backend.

Note

Only available if the track container is not read-only

Returns:

a mutable reference to the backend

inline auto &trackStateContainerHolder()
requires (!ReadOnly)

Retrieve the holder of the track state container.

Note

Only available if the track container is not read-only

Returns:

The track state container including it’s holder

inline const auto &trackStateContainer() const

Get a const reference to the track state container backend.

Returns:

a const reference to the backend

inline const auto &trackStateContainerHolder() const

Retrieve the holder of the track state container.

Returns:

The track state container including it’s holder

Public Types

using const_iterator = Acts::ContainerIndexIterator<TrackContainer, ConstTrackProxy, true>

using ConstTrackProxy = Acts::TrackProxy<track_container_t, traj_t, holder_t, true>

Alias for the const version of a track proxy, with the same backends as this container.

using ConstTrackStateProxy = typename MultiTrajectory<traj_t>::ConstTrackStateProxy

using IndexType = TrackIndexType

The index type of the track container, taken from the container backend.

using iterator = Acts::ContainerIndexIterator<TrackContainer, TrackProxy, false>

using size_type = IndexType

using TrackContainerBackend = track_container_t

using TrackProxy = Acts::TrackProxy<track_container_t, traj_t, holder_t, false>

Alias for the mutable version of a track proxy, with the same backends as this container.

using TrackStateContainerBackend = traj_t

using TrackStateProxy = typename MultiTrajectory<traj_t>::TrackStateProxy

Public Functions

inline void clear()
requires (!ReadOnly)

Clear the content of the track container.

Note

Only available if the track container is not read-only

inline constexpr IndexType size() const

Get the size (number of tracks) of the track container.

Returns:

the sixe

Public Static Attributes

static constexpr IndexType kInvalid = kTrackIndexInvalid

Sentinel value that indicates an invalid index.

static constexpr bool ReadOnly = IsReadOnlyTrackContainer<track_container_t>::value

Indicates if this track container is read-only, or if it can be modified.

static constexpr bool TrackStateReadOnly = IsReadOnlyMultiTrajectory<traj_t>::value

Indicates if the track state container is read-only, or if it can be modified.

template<typename track_container_t, typename trajectory_t, template<typename> class holder_t, bool read_only = true>
class TrackProxy

Proxy class representing a single track.

This class provides a view into an associated TrackContainer, and has reference semantics. You can think of it as a pointer to a vector of tracks, which exposes an object-oriented interface for accessing the track properties.

Template Parameters:

• track_container_t – the container backend

• trajectory_t – the track state container backend

• holder_t – ownership management class for the backend

• read_only – true if this track container is not mutable

Constructors and assignment operator

Public constructors and assignment operators for TrackProxy only allow construction from another TrackProxy. You should generally not have to construct TrackProxy manually.

inline TrackProxy(const MutableTrackProxy &other)

Copy constructor from a mutable track proxy.

This is always valid, either mutable to mutable or mutable to const

Parameters:

other – the other track state proxy

inline TrackProxy &operator=(const MutableTrackProxy &other)

Copy assignment operator from mutable track proxy.

This is always valid, either mutable to mutable or mutable to const

Parameters:

other – the other track state proxy

TrackProxy properties

Methods that give access to the properties of a track represented by TrackProxy.

Many of these methods come in a const and a non-const version. The non-const version is only available if you have an instance of TrackProxy that does not have the read_only template parameter set to true, even if you hold it as an lvalue.

inline IndexType tipIndex() const

Get the tip index, i.e.

the entry point into the track state container

Returns:

the tip index by value

inline IndexType stemIndex() const

Index of the stem, i.e.

the innermost track state of the track. This might be invalid, signifying that the track state is not forward-linked.

Returns:

the stem index

inline IndexType &tipIndex()
requires (!ReadOnly)

Get a mutable reference to the tip index, i.e.

the entry point into the track container

Note

Only available if the track proxy is not read-only

Returns:

mutable reference to the tip index

inline IndexType &stemIndex()
requires (!ReadOnly)

Index of the stem, i.e.

the innermost track state of the track. This might be invalid, signifying that the track state is not forward-linked.

Note

Only available if the track proxy is not read-only

Returns:

mutable reference to the stem index

inline const Surface &referenceSurface() const

Get the reference surface of the track (e.g.

the perigee)

Returns:

the reference surface

inline void setReferenceSurface(std::shared_ptr<const Surface> srf)
requires (!ReadOnly)

Set a new reference surface for this track.

Parameters:

srf – The surface to set

inline bool hasReferenceSurface() const

Returns whether the track has a reference surface or not.

Returns:

whether a surface exists or not

inline ConstParameters parameters() const

Get the parameters of the track at the reference surface (e.g.

perigee). Const version

Returns:

Proxy vector for the parameters

inline ConstCovariance covariance() const

Get the covariance of the track at the reference surface (e.g.

perigee). Const version

Returns:

Proxy matrix for the covariance

inline Parameters parameters()
requires (!ReadOnly)

Get the parameters of the track at the reference surface (e.g.

perigee). Mutable version

Note

Only available if the track proxy is not read-only

Returns:

Proxy vector for the parameters

inline Covariance covariance()
requires (!ReadOnly)

Get the covariance of the track at the reference surface (e.g.

perigee). Mutable version

Note

Only available if the track proxy is not read-only

Returns:

Proxy matrix for the covariance

inline double theta() const

Access the theta parameter of the track at the reference surface.

Returns:

The theta parameter

inline double phi() const

Access the phi parameter of the track at the reference surface.

Returns:

The phi parameter

inline double loc0() const

Access the loc0 parameter of the track at the reference surface.

Returns:

The loc0 parameter

inline double loc1() const

Access the loc1 parameter of the track at the reference surface.

Returns:

The loc1 parameter

inline double time() const

Access the time parameter of the track at the reference surface.

Returns:

The time parameter

inline double qOverP() const

Access the q/p (curvature) parameter of the track at the reference surface.

Returns:

The q/p parameter

inline ParticleHypothesis particleHypothesis() const

Get the particle hypothesis.

Returns:

the particle hypothesis

inline void setParticleHypothesis(const ParticleHypothesis &particleHypothesis)
requires (!ReadOnly)

Set a new particle hypothesis for this track.

Note

Only available if the track proxy is not read-only

Parameters:

particleHypothesis – The particle hypothesis to set

inline double charge() const

Get the charge of the tack.

Note

this depends on the charge hypothesis

Returns:

The absolute track momentum

inline double absoluteMomentum() const

Get the absolute momentum of the tack.

Returns:

The absolute track momentum

inline double transverseMomentum() const

Get the transverse momentum of the track.

Returns:

The track transverse momentum value

inline Vector3 direction() const

Get a unit vector along the track direction at the reference surface.

Returns:

The direction unit vector

inline Vector3 momentum() const

Get the global momentum vector.

Returns:

the global momentum vector

inline unsigned int nTrackStates() const

Return the number of track states associated to this track.

Note

This is calculated by iterating over the track states which is somewhat expensive. Consider caching this value if you need It more than once.

Returns:

The number of track states

inline unsigned int &nMeasurements()
requires (!ReadOnly)

Return a mutable reference to the number of measurements for the track.

Mutable version

Note

Only available if the track proxy is not read-only

Returns:

The number of measurements

inline unsigned int nMeasurements() const

Return the number of measurements for the track.

Const version

Returns:

The number of measurements

inline unsigned int &nHoles()
requires (!ReadOnly)

Return a mutable reference to the number of holes for the track.

Mutable version

Note

Only available if the track proxy is not read-only

Returns:

The number of holes

inline unsigned int nHoles() const

Return the number of measurements for the track.

Const version

Returns:

The number of measurements

inline unsigned int &nOutliers()
requires (!ReadOnly)

Return a mutable reference to the number of outliers for the track.

Mutable version

Note

Only available if the track proxy is not read-only

Returns:

The number of outliers

inline unsigned int nOutliers() const

Return the number of outliers for the track.

Const version

Returns:

The number of outliers

inline unsigned int &nSharedHits()
requires (!ReadOnly)

Return a mutable reference to the number of shared hits for the track.

Mutable version

Note

Only available if the track proxy is not read-only

Returns:

The number of shared hits

inline unsigned int nSharedHits() const

Return the number of shared hits for the track.

Const version

Returns:

The number of shared hits

inline float &chi2()
requires (!ReadOnly)

Return a mutable reference to the chi squared Mutable version.

Note

Only available if the track proxy is not read-only

Returns:

The chi squared

inline float chi2() const

Return the chi squared for the track.

Const version

Returns:

The chi squared

inline unsigned int &nDoF()
requires (!ReadOnly)

Return a mutable reference to the number of degrees of freedom for the track.

Mutable version

Note

Only available if the track proxy is not read-only

Returns:

The number of degrees of freedom

inline unsigned int nDoF() const

Return the number of degrees of freedom for the track.

Const version

Returns:

The number of degrees of freedom

inline IndexType index() const

Return the index of this track in the track container.

Note

This is separate from the tip index

Returns:

the track index

TrackProxy track state access

Methods that give access to the track states of a track represented by TrackProxy.

inline ConstTrackStateProxy outermostTrackState() const

Return a const track state proxy to the outermost track state.

Returns:

The outermost track state proxy

inline TrackStateProxy outermostTrackState()
requires (!ReadOnly)

Return a mutable track state proxy to the outermost track state.

Returns:

The outermost track state proxy

inline auto innermostTrackState() const

Return a const track state proxy to the innermost track state.

Note

This is only available, if the track is forward linked

Returns:

The innermost track state proxy

inline auto innermostTrackState()
requires (!ReadOnly)

Return a mutable track state proxy to the innermost track state.

Note

This is only available, if the track is forward linked

Note

Only available if the track proxy is not read-only

Returns:

The innermost track state proxy

inline auto trackStatesReversed() const

Get a range over the track states of this track.

Return value is compatible with range based for loop. Const version

Note

This range is from the outside inwards!

Returns:

Track state range to iterate over

inline auto trackStatesReversed()
requires (!ReadOnly)

Get a range over the track states of this track.

Return value is compatible with range based for loop. Mutable version

Note

Only available if the track proxy is not read-only

Note

This range is from the outside inwards!

Returns:

Track state range to iterate over

inline auto trackStates() const

Get a range over the track states of this track.

Return value is compatible with range based for loop. This overload returns a const-only track state range, which means you cannot modify the track states obtained in the iteration.

Note

This range is from the inside out!

Warning

This access direction is only possible if the track states are forward-linked.

Returns:

Track state range to iterate over

inline auto trackStates()
requires (!ReadOnly)

Get a range over the track states of this track.

Return value is compatible with range based for loop. This overload returns a mutable track state range, which means you can modify the track states obtained in the iteration.

Note

Only available if the track proxy is not read-only

Note

This range is from the inside out!

Warning

This access direction is only possible if the track states are forward-linked.

Returns:

Track state range to iterate over

TrackProxy track state manipulation

Methods that manipulate the track states of a track represented by TrackProxy.

inline void linkForward()
requires (!ReadOnly)

Forward connect a track.

This means setting indices from the inside out on all track states.

Note

Only available if the track proxy is not read-only

inline auto appendTrackState(TrackStatePropMask mask = TrackStatePropMask::All)
requires (!ReadOnly)

Append a track state to this track.

This will modify the tip index to point at the newly created track state, which will be directly after the previous track state at tip index.

Note

Only available if the track proxy is not read-only

Parameters:

mask – The allocation prop mask for the new track state

Returns:

The newly added track state

template<TrackProxyConcept track_proxy_t>
inline void copyFrom(const track_proxy_t &other, bool copyTrackStates = true)
requires (!ReadOnly)

Copy the content of another track proxy into this one.

Note

Only available if the track proxy is not read-only

Template Parameters:

track_proxy_t – the other track proxy’s type

Parameters:

• other – The track proxy

• copyTrackStates – Copy the track state sequence from other

inline TrackProxy shallowCopy()
requires (!ReadOnly)

Creates a shallow copy of the track.

Track states are not copied, but the resulting track points at the same track states as the original.

Note

Only available if the track proxy is not read-only

inline void reverseTrackStates(bool invertJacobians = false)
requires (!ReadOnly)

Reverse the ordering of track states for this track Afterwards, the previous endpoint of the track state sequence will be the “innermost” track state.

Note

Only available if the track proxy is not read-only

Note

This is dangerous with branching track state sequences, as it will break them

Note

This also automatically forward-links the track!

Parameters:

invertJacobians – Whether to invert the Jacobians of the track states

TrackProxy generic component access

Methods that give access to generic components of a track represented by TrackProxy.

Internally, a compile-time hash of the component name is used to identify which component is being requested. Most of the named methods in TrackProxy properties use these methods to retrieve the actual data.

A number of overloads exist, where you can either supply the HashedString key as a template parameter or a runtime argument. The former has the advantage of being guaranteed to be evaluated at compile-time.

template<typename T, HashedString key>
inline constexpr T &component()
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Template Parameters:

• T – The type of the component to access

• key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T>
inline constexpr T &component(HashedString key)
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T>
inline constexpr T &component(std::string_view key)
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Note

This might hash the key at runtime instead of compile-time

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T, HashedString key>
inline constexpr const T &component() const

Retrieve a const reference to a component.

Template Parameters:

• T – The type of the component to access

• key – String key for the component to access

Returns:

Const reference to the component given by key

template<typename T>
inline constexpr const T &component(HashedString key) const

Retrieve a const reference to a component.

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Const reference to the component given by key

template<typename T>
inline constexpr const T &component(std::string_view key) const

Retrieve a const reference to a component.

Note

This might hash the key at runtime instead of compile-time

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Const reference to the component given by key

Public Types

using ConstCovariance = typename detail_lt::FixedSizeTypes<eBoundSize, true>::CovarianceMap

Same as Covariance, but with const semantics.

using ConstParameters = typename detail_lt::FixedSizeTypes<eBoundSize, true>::CoefficientsMap

Same as Parameters, but with const semantics.

using ConstProxyType = ConstTrackProxy

Alias for an associated const track proxy, with the same backends.

using ConstTrackProxy = TrackProxy<track_container_t, trajectory_t, holder_t, true>

Alias for the const version of this track proxy, with the same backends.

using ConstTrackStateProxy = typename Trajectory::ConstTrackStateProxy

Alias for an associated const track state proxy, with the same backends.

using Container = track_container_t

The track container backend given as a template parameter.

using Covariance = typename detail_lt::FixedSizeTypes<eBoundSize, false>::CovarianceMap

Map-type for a bound covariance.

This has reference semantics, i.e. points at a matrix by an internal pointer.

using IndexType = typename Container::IndexType

The index type of the track container.

using MutableTrackProxy = TrackProxy<track_container_t, trajectory_t, holder_t, false>

Alias for the mutable version of this track proxy, with the same backends.

using Parameters = typename detail_lt::FixedSizeTypes<eBoundSize, false>::CoefficientsMap

Map-type for a bound parameter vector.

This has reference semantics, i.e. points at a matrix by an internal pointer.

using TrackStateProxy = typename Trajectory::TrackStateProxy

Alias for an associated mutable track state proxy, with the same backends.

using Trajectory = trajectory_t

The track state container backend given as a template parameter.

Public Functions

inline const auto &container() const

Return a reference to the track container backend, const version.

Returns:

reference to the track container backend

inline auto &container()
requires (!ReadOnly)

Return a reference to the track container backend, mutable version.

Note

Only available if the track proxy is not read-only

Returns:

reference to the track container backend

inline BoundTrackParameters createParametersAtReference() const

Return the track parameters at the reference surface.

Note

The parameters are created on the fly

Returns:

the track parameters

inline BoundTrackParameters createParametersFromState(const ConstTrackStateProxy &trackState) const

Convert a track state into track parameters.

Note

The parameters are created on the fly

Returns:

the track parameters

inline bool operator==(const TrackProxy &other) const

Equality operator with another track proxy Checks the container identity and the track index.

Returns:

True if the track proxies refer to the same track

Public Static Attributes

static constexpr IndexType kInvalid = Container::kInvalid

Sentinel value that indicates an invalid index.

static constexpr bool ReadOnly = read_only

Indicates whether this track proxy is read-only or if it can be modified.

template<typename trajectory_t, std::size_t M, bool read_only = true>
class TrackStateProxy

Proxy object to access a single point on the trajectory.

Template Parameters:

• SourceLink – Type to link back to an original measurement

• M – Maximum number of measurement dimensions

• read_only – true for read-only access to underlying storage

Constructors and assignment operator

Public constructors and assignment operators for TrackStateProxy only allow construction from another TrackStateProxy. You should generally not have to construct TrackStateProxy manually.

inline TrackStateProxy(const TrackStateProxy<Trajectory, M, false> &other)

Constructor and assignment operator to construct TrackStateProxy from mutable.

Parameters:

other – The other TrackStateProxy to construct from

inline TrackStateProxy &operator=(const TrackStateProxy<Trajectory, M, false> &other)

Assignment operator to from mutable TrackStateProxy.

Parameters:

other – The other TrackStateProxy to construct from

Returns:

Reference to this TrackStateProxy

Track state properties

Properties of the track state represented by TrackStateProxy.

Many of these methods come in a const and a non-const version. The non-const version is only available if you have an instance of TrackStateProxy that does not have the read_only template parameter set to true, even if you hold it as an lvalue.

The track states each have an index in the track state container. The sequence of track states is implemented as a one or two-way linked list, which uses indices into the same container.

Each track state has a previous index, which points at the track state immediately preceding. A track state with a previous index of kInvalid is the first (innermost) track state in a track or track candidate. This is also referred to as a stem at the track level.

During track finding and fitting, track states are usually appended to the sequence, populating the previous index of the new track state. Combinatorial track finding can produce track states which fork in this way, by having more than one track state with the same previous index.

The track states have static, optional and dynamic properties. Static properties are always present, and can always be retrieved. Optional components use an extra indirection mechanism that coordinates with the backend to allow both not having the component set, or sharing it with other track states. An example is a branching trajectory from track finding which shares the same predicted parameter vector and associated covariance.

Optional components are

• predicted parameters and covariance

• filtered parameters and covariance

• smoothed parameters and covariance

• jacobian

• calibrated measurement info including projector

They can be unset via unset, getMask can be used to check which components are present. The first four are shareable between track states via shareFrom.

inline IndexType index() const

Index within the trajectory.

Returns:

the index

inline IndexType previous() const

Return the index of the track state previous in the track sequence.

Returns:

The index of the previous track state.

inline IndexType &previous()
requires (!ReadOnly)

Return a mutable reference to the index of the track state ‘previous’ in the track sequence.

Note

Only available if the track state proxy is not read-only

Returns:

The index of the previous track state.

inline bool hasPrevious() const

Return whether this track state has a previous (parent) track state.

Returns:

Boolean indicating whether a previous track state exists

TrackStatePropMask getMask() const

Build a mask that represents all the allocated components of this track state proxy.

Returns:

The generated mask

inline void unset(TrackStatePropMask target)
requires (!ReadOnly)

Unset an optional track state component.

Note

Only available if the track state proxy is not read-only

Parameters:

target – The component to unset

inline void addComponents(TrackStatePropMask mask)
requires (!ReadOnly)

Add additional components to the track state.

Note

Only available if the track state proxy is not read-only

Parameters:

mask – The bitmask that instructs which components to allocate

inline const Surface &referenceSurface() const

Reference surface.

Returns:

the reference surface

inline bool hasReferenceSurface() const

Returns if the track state has a non nullptr surface associated.

Returns:

whether a surface exists or not

inline void setReferenceSurface(std::shared_ptr<const Surface> srf)
requires (!ReadOnly)

Set the reference surface to a given value.

Note

This overload is only present in case ReadOnly is false.

Parameters:

srf – Shared pointer to the surface to set

inline float &chi2()
requires (!ReadOnly)

Getter/setter for chi2 value associated with the track state This overload returns a mutable reference, which allows setting a new value directly into the backing store.

Note

this overload is only enabled in case the proxy is not read-only

Returns:

Mutable reference to the chi2 value

inline float chi2() const

Getter for the chi2 value associated with the track state.

This overload returns a copy of the chi2 value, and thus does not allow modification of the value in the backing storage.

Returns:

the chi2 value of the track state

inline double &pathLength()
requires (!ReadOnly)

Getter for the path length associated with the track state.

This overloaded is only enabled if not read-only, and returns a mutable reference.

Returns:

Mutable reference to the pathlength.

inline double pathLength() const

Getter for the path length.

Returns a copy of the path length value.

Returns:

The path length of this track state

inline TrackStateType typeFlags()
requires (!ReadOnly)

Getter for the type flags associated with the track state.

This overloaded is only enabled if not read-only, and returns a mutable reference.

Returns:

reference to the type flags.

inline ConstTrackStateType typeFlags() const

Getter for the type flags.

Returns a copy of the type flags value.

Returns:

The type flags of this track state

Track state parameters

ConstParameters parameters() const

Track parameters vector.

This tries to be somewhat smart and return the first parameters that are set in this order: predicted -> filtered -> smoothed

Returns:

one of predicted, filtered or smoothed parameters

ConstCovariance covariance() const

Track parameters covariance matrix.

This tries to be somewhat smart and return the first parameters that are set in this order: predicted -> filtered -> smoothed

Returns:

one of predicted, filtered or smoothed covariances

inline ConstParameters predicted() const

Predicted track parameters vector.

Returns:

The predicted parameters

inline Parameters predicted()
requires (!ReadOnly)

inline ConstCovariance predictedCovariance() const

Predicted track parameters covariance matrix.

Returns:

The predicted track parameter covariance

inline Covariance predictedCovariance()
requires (!ReadOnly)

inline bool hasPredicted() const

Check whether the predicted parameters+covariance is set.

Returns:

Whether it is set or not

inline ConstParameters filtered() const

Filtered track parameters vector.

Note

Const version

Returns:

The filtered parameters

inline Parameters filtered()
requires (!ReadOnly)

Filtered track parameters vector.

Note

Mutable version

Returns:

The filtered parameters

inline ConstCovariance filteredCovariance() const

Filtered track parameters covariance matrix.

Note

Const version

Returns:

The filtered parameters covariance

inline Covariance filteredCovariance()
requires (!ReadOnly)

Filtered track parameters covariance matrix.

Note

Mutable version

Returns:

The filtered parameters covariance

inline bool hasFiltered() const

Return whether filtered parameters+covariance is set.

Returns:

Whether it is set

inline ConstParameters smoothed() const

Smoothed track parameters vector.

Note

Const version

Returns:

The smoothed parameters

inline Parameters smoothed()
requires (!ReadOnly)

Smoothed track parameters vector.

Note

Mutable version

Returns:

The smoothed parameters

inline ConstCovariance smoothedCovariance() const

Smoothed track parameters covariance matrix.

Note

Const version

Returns:

the parameter covariance matrix

inline Covariance smoothedCovariance()
requires (!ReadOnly)

Smoothed track parameters covariance matrix.

Note

Mutable version

Returns:

the parameter covariance matrix

inline bool hasSmoothed() const

Return whether smoothed parameters+covariance is set.

Returns:

Whether it is set

inline ConstCovariance jacobian() const

Returns the jacobian from the previous trackstate to this one.

Note

Const version

Returns:

The jacobian matrix

inline Covariance jacobian()
requires (!ReadOnly)

Returns the jacobian from the previous trackstate to this one.

Note

Mutable version

Returns:

The jacobian matrix

inline bool hasJacobian() const

Returns whether a jacobian is set for this trackstate.

Returns:

Whether it is set

Track state measurement properties

Properties of the measurement associated with the track state represented. This consists of a vector and an associated square matrix of a measurement dimension which is between one and the size of the track parametrization. The measurement coordinate frame is required to be a strict subset of the bound track parametrization on the local geometry coordinate frame, i.e. using a pure projector matrix to convert from the bound parametrization to the measurement frame is possible.

The track state stores the parameter vector and covariance, and the backend is given the possibility to do so in a jagged way, i.e. only storing the number of values needed. This requires calling allocateCalibrated before storing the measurements (even if it might be a no-op).

The projector matrix is packed as a bitset, which is converted to a matrix on-demand (and therefore returned by value).

The track state also includes a SourceLink which acts as a proxy to the original uncalibrated measurement that the calibrated measurement was derived from. It is set and returned by value, to allow unpacking / repacking by the backend, if needed.

template<std::ranges::sized_range index_range_t> inline void setProjectorSubspaceIndices (const index_range_t &subspaceIndices) requires(!ReadOnly &&std

Set the projector subspace indices.

Parameters:

subspaceIndices – The projector subspace indices to set

inline bool hasProjector() const

Returns whether a projector is set.

Returns:

Whether it is set

inline BoundSubspaceIndices projectorSubspaceIndices() const

Returns the projector subspace indices.

Returns:

The projector subspace indices

template<std::size_t measdim>
inline SubspaceIndices<measdim> projectorSubspaceIndices() const

Returns the projector subspace indices.

Returns:

The projector subspace indices

inline VariableBoundSubspaceHelper projectorSubspaceHelper() const

Creates a variable size subspace helper.

Returns:

The subspace helper

template<std::size_t measdim>
inline FixedBoundSubspaceHelper<measdim> projectorSubspaceHelper() const

Creates a fixed size subspace helper.

Returns:

The subspace helper

SourceLink getUncalibratedSourceLink() const

Uncalibrated measurement in the form of a source link.

Const version

Returns:

The uncalibrated measurement source link

inline void setUncalibratedSourceLink(SourceLink &&sourceLink)
requires (!ReadOnly)

Set an uncalibrated source link.

Parameters:

sourceLink – The uncalibrated source link to set

inline bool hasUncalibratedSourceLink() const

Check if the point has an associated uncalibrated measurement.

Returns:

Whether it is set

inline bool hasCalibrated() const

Check if the point has an associated calibrated measurement.

Returns:

Whether it is set

template<std::size_t measdim>
inline ConstCalibrated<measdim> calibrated() const

Full calibrated measurement vector.

Might contain additional zeroed dimensions.

Note

Const version

Returns:

The measurement vector

template<std::size_t measdim>
inline Calibrated<measdim> calibrated()
requires (!ReadOnly)

Full calibrated measurement vector.

Might contain additional zeroed dimensions.

Note

Mutable version

Returns:

The measurement vector

template<std::size_t measdim>
inline ConstCalibratedCovariance<measdim> calibratedCovariance() const

Const full calibrated measurement covariance matrix.

The effective covariance is located in the top left corner, everything else is zeroed.

Returns:

The measurement covariance matrix

template<std::size_t measdim>
inline CalibratedCovariance<measdim> calibratedCovariance()
requires (!ReadOnly)

Mutable full calibrated measurement covariance matrix.

The effective covariance is located in the top left corner, everything else is zeroed.

Returns:

The measurement covariance matrix

inline EffectiveCalibrated effectiveCalibrated()
requires (!ReadOnly)

Mutable dynamic measurement vector with only the valid dimensions.

Warning

The dynamic vector has a runtime overhead!

Returns:

The effective calibrated measurement vector

inline ConstEffectiveCalibrated effectiveCalibrated() const

Const dynamic measurement vector with only the valid dimensions.

Warning

The dynamic matrix has a runtime overhead!

Returns:

The effective calibrated measurement vector

inline EffectiveCalibratedCovariance effectiveCalibratedCovariance()

Mutable dynamic measurement covariance matrix with only the valid dimensions.

Warning

The dynamic matrix has a runtime overhead!

Returns:

The effective calibrated covariance matrix

inline ConstEffectiveCalibratedCovariance effectiveCalibratedCovariance() const

Const dynamic measurement covariance matrix with only the valid dimensions.

Warning

The dynamic matrix has a runtime overhead!

Returns:

The effective calibrated covariance matrix

inline IndexType calibratedSize() const

Return the (dynamic) number of dimensions stored for this measurement.

Note

Depending on the backend, this size is used to determine the memory range of the measurement vector and covariance.

Returns:

The number of dimensions

inline void allocateCalibrated(std::size_t measdim)

Allocate storage to be able to store a measurement of size measdim.

This must be called before setting the measurement content.

Note

This does not allocate if an allocation of the same size already exists

Note

This will zero-initialize the allocated storage

Note

This is an error if an existing allocation has different size

template<typename val_t, typename cov_t> inline void allocateCalibrated (const Eigen::DenseBase< val_t > &val, const Eigen::DenseBase< cov_t > &cov) requires(Concepts

Allocate storage and assign the given vector and covariance to it.

The dimension is inferred from the given vector and matrix.

Note

This does not allocate if an allocation of the same size already exists

Note

This throws an exception if an existing allocation has different size

Template Parameters:

• val_t – Type of the vector

• cov_t – Type of the covariance matrix

Parameters:

• val – The measurement vector

• cov – The covariance matrix

Sharing and copying

Methods to share and copy track state components. Sharing means setting up more than one track state to point to the same component.

Shareable components are

• predicted parameters and covariance

• filtered parameters and covariance

• smoothed parameters and covariance

• jacobian

See TrackStatePropMask.

inline void shareFrom(TrackStatePropMask shareSource, TrackStatePropMask shareTarget)
requires (!ReadOnly)

Share a shareable component within this track state.

Parameters:

• shareSource – Which component to share from

• shareTarget – Which component to share as. This should be different from as shareSource, e.g. predicted can be shared as filtered.

template<bool ReadOnlyOther>
inline void shareFrom(const TrackStateProxy<Trajectory, M, ReadOnlyOther> &other, TrackStatePropMask component)
requires (!ReadOnly)

Share a shareable component from another track state.

Note

The track states both need to be stored in the same MultiTrajectory instance

Parameters:

• other – Track state proxy to share component from

• component – Which component to share.

template<bool ReadOnlyOther>
inline void shareFrom(const TrackStateProxy<Trajectory, M, ReadOnlyOther> &other, TrackStatePropMask shareSource, TrackStatePropMask shareTarget)
requires (!ReadOnly)

Share a shareable component from another track state.

Note

Shareable components are predicted, filtered, smoothed, calibrated, jacobian, or projector. See TrackStatePropMask.

Parameters:

• other – Track state proxy to share component(s) from

• shareSource – Which component to share from

• shareTarget – Which component to share as. This can be be different from as shareSource, e.g. predicted can be shared as filtered.

template<TrackStateProxyConcept track_state_proxy_t>
inline void copyFrom(const track_state_proxy_t &other, TrackStatePropMask mask = TrackStatePropMask::All, bool onlyAllocated = true)
requires (!ReadOnly)

Copy the contents of another track state proxy into this one.

Note

If the this track state proxy does not have compatible allocations with the source track state proxy, and onlyAllocated is false, an exception is thrown.

Note

The mask parameter will not cause a copy of components that are not allocated in the source track state proxy.

Parameters:

• other – The other track state to copy from

• mask – An optional mask to determine what to copy from

• onlyAllocated – Whether to only copy allocated components

Track state proxy Generic component access

template<HashedString key>
inline constexpr bool has() const

Check if a component is set.

Template Parameters:

key – Hashed string key to check for

Returns:

true if the component exists, false if not

inline constexpr bool has(HashedString key) const

Check if a component is set.

Parameters:

key – Hashed string key to check for

Returns:

true if the component exists, false if not

inline constexpr bool has(std::string_view key) const

Check if a component is set.

Note

This might hash the key at runtime instead of compile-time

Parameters:

key – String key to check for

Returns:

true if the component exists, false if not

template<typename T, HashedString key>
inline constexpr T &component()
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Template Parameters:

• T – The type of the component to access

• key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T>
inline constexpr T &component(HashedString key)
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T>
inline constexpr T &component(std::string_view key)
requires (!ReadOnly)

Retrieve a mutable reference to a component.

Note

This might hash the key at runtime instead of compile-time

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Mutable reference to the component given by key

template<typename T, HashedString key>
inline constexpr const T &component() const

Retrieve a const reference to a component.

Template Parameters:

• T – The type of the component to access

• key – String key for the component to access

Returns:

Const reference to the component given by key

template<typename T>
inline constexpr const T &component(HashedString key) const

Retrieve a const reference to a component.

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Const reference to the component given by key

template<typename T>
inline constexpr const T &component(std::string_view key) const

Retrieve a const reference to a component.

Note

This might hash the key at runtime instead of compile-time

Template Parameters:

T – The type of the component to access

Parameters:

key – String key for the component to access

Returns:

Const reference to the component given by key

Public Types

template<std::size_t N>
using Calibrated = typename TrackStateTraits<N, ReadOnly>::Calibrated

Map-type for a calibrated measurement vector, where the local measurement dimension is variable.

template<std::size_t N>
using CalibratedCovariance = typename TrackStateTraits<N, ReadOnly>::CalibratedCovariance

Map-type for a calibrated measurement covariance matrix, where the local measurement dimension is variable.

template<std::size_t N>
using ConstCalibrated = typename TrackStateTraits<N, true>::Calibrated

Same as Calibrated, but with const semantics.

template<std::size_t N>
using ConstCalibratedCovariance = typename TrackStateTraits<N, true>::CalibratedCovariance

Same as CalibratedCovariance, but with const semantics.

using ConstCovariance = typename TrackStateTraits<M, true>::Covariance

Same as Covariance, but with const semantics.

using ConstEffectiveCalibrated = typename TrackStateTraits<M, true>::EffectiveCalibrated

Same as EffectiveCalibrated, but with const semantics.

using ConstEffectiveCalibratedCovariance = typename TrackStateTraits<M, true>::EffectiveCalibratedCovariance

Same as EffectiveCalibratedCovariance, but with const semantics.

using ConstParameters = typename TrackStateTraits<M, true>::Parameters

Same as Parameters, but with const semantics.

using ConstProxyType = TrackStateProxy<trajectory_t, M, true>

Alias for an associated const track state proxy, with the same backends.

using Covariance = typename TrackStateTraits<M, ReadOnly>::Covariance

Map-type for a bound covariance.

This has reference semantics, i.e. points at a matrix by an internal pointer.

using EffectiveCalibrated = typename TrackStateTraits<M, ReadOnly>::EffectiveCalibrated

Map-type for a measurement vector, where the local measurement dimension is variable.

using EffectiveCalibratedCovariance = typename TrackStateTraits<M, ReadOnly>::EffectiveCalibratedCovariance

Map-type for a measurement covariance matrix, where the local measurement dimension is variable.

using IndexType = TrackIndexType

The index type of the track state container.

using Parameters = typename TrackStateTraits<M, ReadOnly>::Parameters

Map-type for a bound parameter vector.

This has reference semantics, i.e. points at a matrix by an internal pointer.

using Trajectory = trajectory_t

The track state container backend given as a template parameter.

Public Functions

inline const auto &container() const

Get a const reference to the track state container backend.

Returns:

a const reference to the backend

inline auto &container()
requires (!ReadOnly)

Get a mutable reference to the track state container backend.

Returns:

a mutable reference to the backend

inline const MultiTrajectory<Trajectory> &trajectory() const

Return a const reference to the underlying backend container.

Returns:

A const reference to the backend container

inline MultiTrajectory<Trajectory> &trajectory()
requires (!ReadOnly)

Return a mutable reference to the underlying backend container.

Returns:

A reference to the backend container

Public Static Attributes

static constexpr IndexType kInvalid = kTrackIndexInvalid

Sentinel value that indicates an invalid index.

static constexpr bool ReadOnly = read_only

Indicates whether this track state proxy is read-only or if it can be modified.

Friends

friend class Acts::MultiTrajectory< Trajectory >

class TrackingGeometry

The TrackingGeometry class is the owner of the constructed TrackingVolumes.

It enables both, a global search for an asociatedVolume (respectively, if existing, a global search of an associated Layer or the next associated Layer), such as a continuous navigation by BoundarySurfaces between the confined TrackingVolumes.

Public Functions

TrackingGeometry(const std::shared_ptr<TrackingVolume> &highestVolume, const IMaterialDecorator *materialDecorator = nullptr, const GeometryIdentifierHook &hook = {}, const Logger &logger = getDummyLogger())

Constructor.

Parameters:

• highestVolume – is the world volume

• materialDecorator – is a dediated decorator that can assign surface or volume based material to the TrackingVolume

• hook – Identifier hook to be applied to surfaces

• logger – instance of a logger (defaulting to the “silent” one)

~TrackingGeometry()

Destructor.

const Layer *associatedLayer(const GeometryContext &gctx, const Vector3 &gp) const

Forward the associated Layer information.

Parameters:

• gctx – is the context for this request (e.g. alignment)

• gp – is the global position of the call

Returns:

plain pointer to assocaiated layer

const Surface *findSurface(GeometryIdentifier id) const

Search for a surface with the given identifier.

Parameters:

id – is the geometry identifier of the surface

Return values:

• nullptr – if no such surface exists

• pointer – to the found surface otherwise.

const TrackingVolume *findVolume(GeometryIdentifier id) const

Search for a volume with the given identifier.

Parameters:

id – is the geometry identifier of the volume

Return values:

• nullptr – if no such volume exists

• pointer – to the found volume otherwise.

const std::unordered_map<GeometryIdentifier, const Surface*> &geoIdSurfaceMap() const

Access to the GeometryIdentifier - Surface association map.

const TrackingVolume *highestTrackingVolume() const

Access to the world volume.

Returns:

plain pointer to the world volume

std::shared_ptr<const TrackingVolume> highestTrackingVolumePtr() const

Access to the world volume.

Returns:

shared pointer to the world volume

const TrackingVolume *lowestTrackingVolume(const GeometryContext &gctx, const Vector3 &gp) const

return the lowest tracking Volume

Parameters:

• gctx – The current geometry context object, e.g. alignment

• gp – is the global position of the call

Returns:

plain pointer to the lowest TrackingVolume

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const

Visit all sensitive surfaces.

Note

If a context is needed for the visit, the visitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – The callable. Will be called for each sensitive surface that is found, a selection of the surfaces can be done in the visitor

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor, bool restrictToSensitives) const

Visit all reachable surfaces.

Note

If a context is needed for the visit, the visitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

• visitor – The callable. Will be called for each reachable surface that is found, a selection of the surfaces can be done in the visitor

• restrictToSensitives – If true, only sensitive surfaces are visited

template<TrackingVolumeVisitor visitor_t>
inline void visitVolumes(visitor_t &&visitor) const

Visit all reachable tracking volumes.

Note

If a context is needed for the visit, the visitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – The callable. Will be called for each reachable volume that is found, a selection of the volumes can be done in the visitor

void visualize(IVisualization3D &helper, const GeometryContext &gctx, const ViewConfig &viewConfig = s_viewVolume, const ViewConfig &portalViewConfig = s_viewPortal, const ViewConfig &sensitiveViewConfig = s_viewSensitive) const

Visualize a tracking geometry including substructure.

Parameters:

• helper – The visualization helper that implement the output

• gctx – The geometry context

• viewConfig – Global view config

• portalViewConfig – View config for portals

• sensitiveViewConfig – View configuration for sensitive surfaces

class TrackingVolume : public Acts::Volume

Full Volume description used in Tracking, it inherits from Volume to get the geometrical structure.

A TrackingVolume at navigation level can provide the (layer) material

information / internal navigation with in 5 different ways:

--- a) Static confinement of Layers
--- b) detached sub volumes
--- b) unordered (arbitrarily oriented) layers
--- d) unordered sub volumes
--- e) unordered layers AND unordered subvolumes

The TrackingVolume can also be a simple container of other TrackingVolumes

In addition it is capable of holding a subarray of Layers and TrackingVolumes.

Unnamed Group

const Layer *associatedLayer(const GeometryContext &gctx, const Vector3 &position) const

Interface of TrackingVolume in the Gen1 geometry model.

Note

This interface is being replaced, and is subject to removal Return the associated Layer to the global position

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the associated global position

Returns:

plain pointer to layer object

boost::container::small_vector<LayerIntersection, 10> compatibleLayers(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const NavigationOptions<Layer> &options) const

Resolves the volume into (compatible) Layers.

This is the method for the propagator/extrapolator

Template Parameters:

options_t – Type of navigation options object for decomposition

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – Position for the search

• direction – Direction for the search

• options – The templated navigation options

Returns:

vector of compatible intersections with layers

boost::container::small_vector<BoundaryIntersection, 4> compatibleBoundaries(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const NavigationOptions<Surface> &options, const Logger &logger = getDummyLogger()) const

Returns all boundary surfaces sorted by the user.

Template Parameters:

• options_t – Type of navigation options object for decomposition

• sorter_t – Type of the boundary surface sorter

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – The position for searching

• direction – The direction for searching

• options – The templated navigation options

• logger – A Logger instance

Returns:

is the templated boundary intersection

const LayerArray *confinedLayers() const

Return the confined static layer array - if it exists.

Returns:

the BinnedArray of static layers if exists

std::shared_ptr<const TrackingVolumeArray> confinedVolumes() const

Return the confined volumes of this container array - if it exists.

const MutableTrackingVolumeVector denseVolumes() const

Return the confined dense volumes.

const TrackingVolumeBoundaries &boundarySurfaces() const

Method to return the BoundarySurfaces.

void assignBoundaryMaterial(std::shared_ptr<const ISurfaceMaterial> surfaceMaterial, BoundarySurfaceFace bsFace)

Set the boundary surface material description.

The material is usually derived in a complicated way and loaded from a framework given source. As various volumes could potentially share the the same material description, it is provided as a shared object

Parameters:

• surfaceMaterial – Material description of this volume

• bsFace – Specifies which boundary surface to assign the material to

void glueTrackingVolume(const GeometryContext &gctx, BoundarySurfaceFace bsfMine, TrackingVolume *neighbor, BoundarySurfaceFace bsfNeighbor)

Glue another tracking volume to this one.

• if common face is set the glued volumes are sharing the boundary, down to the last navigation volume

Parameters:

• gctx – The current geometry context object, e.g. alignment

• bsfMine – is the boundary face indicater where to glue

• neighbor – is the TrackingVolume to be glued

• bsfNeighbor – is the boundary surface of the neighbor

void glueTrackingVolumes(const GeometryContext &gctx, BoundarySurfaceFace bsfMine, const std::shared_ptr<TrackingVolumeArray> &neighbors, BoundarySurfaceFace bsfNeighbor)

Glue another tracking volume to this one.

• if common face is set the glued volumes are sharing the boundary, down to the last navigation volume

Parameters:

• gctx – The current geometry context object, e.g. alignment

• bsfMine – is the boundary face indicater where to glue

• neighbors – are the TrackingVolumes to be glued

• bsfNeighbor – are the boundary surface of the neighbors

void updateBoundarySurface(BoundarySurfaceFace bsf, std::shared_ptr<const BoundarySurfaceT<TrackingVolume>> bs, bool checkmaterial = true)

Provide a new BoundarySurface from the glueing.

Parameters:

• bsf – is the boundary face indicater where to glue

• bs – is the new boundary surface

• checkmaterial – is a flag how to deal with material, if true:

  • if the old boundary surface had a material description but the new one has not, keep the current one

  • in all other cases just assign the new boundary surface

void registerGlueVolumeDescriptor(std::unique_ptr<GlueVolumesDescriptor> gvd)

Register the outside glue volumes - ordering is in the TrackingVolume Frame:

• negativeFaceXY

• (faces YZ, ZY, radial faces)

• positiveFaceXY

Parameters:

gvd – register a new GlueVolumeDescriptor

GlueVolumesDescriptor &glueVolumesDescriptor()

Register the outside glue volumes - ordering is in the TrackingVolume Frame:

• negativeFaceXY

• (faces YZ, ZY, radial faces)

• positiveFaceXY

void visualize(IVisualization3D &helper, const GeometryContext &gctx, const ViewConfig &viewConfig, const ViewConfig &portalViewConfig, const ViewConfig &sensitiveViewConfig) const

Produces a 3D visualization of this tracking volume.

Parameters:

• helper – The visualization helper describing the output format

• gctx – The geometry context

• viewConfig – The view configuration

• portalViewConfig – View configuration for portals

• sensitiveViewConfig – View configuration for sensitive surfaces

void setNavigationPolicy(std::unique_ptr<INavigationPolicy> policy)

Register a navigation policy with this volume.

The argument can not be nullptr.

Parameters:

policy – is the navigation policy to be registered

void initializeNavigationCandidates(const NavigationArguments &args, AppendOnlyNavigationStream &stream, const Logger &logger) const

Populate the navigation stream with navigation candidates from this volume.

Internally, this consults the registered navigation policy, where the default is a noop.

Parameters:

• args – are the navigation arguments

• stream – is the navigation stream to be updated

• logger – is the logger

Public Types

using MutablePortalRange = detail::TransformRange<detail::Dereference, std::vector<std::shared_ptr<Portal>>>

using MutableSurfaceRange = detail::TransformRange<detail::Dereference, std::vector<std::shared_ptr<Surface>>>

using MutableVolumeRange = detail::TransformRange<detail::Dereference, std::vector<std::unique_ptr<TrackingVolume>>>

using PortalRange = detail::TransformRange<detail::ConstDereference, const std::vector<std::shared_ptr<Portal>>>

using SurfaceRange = detail::TransformRange<detail::ConstDereference, const std::vector<std::shared_ptr<Surface>>>

using VolumeRange = detail::TransformRange<detail::ConstDereference, const std::vector<std::unique_ptr<TrackingVolume>>>

Public Functions

TrackingVolume() = delete

TrackingVolume(const TrackingVolume&) = delete

TrackingVolume(const Transform3 &transform, std::shared_ptr<VolumeBounds> volbounds, const std::string &volumeName = "undefined")

Constructor for a container Volume.

• vacuum filled volume either as a for other tracking volumes

Parameters:

• transform – is the global 3D transform to position the volume in space

• volbounds – is the description of the volume boundaries

• volumeName – is a string identifier

TrackingVolume(const Transform3 &transform, std::shared_ptr<VolumeBounds> volumeBounds, std::shared_ptr<const IVolumeMaterial> volumeMaterial, std::unique_ptr<const LayerArray> staticLayerArray = nullptr, std::shared_ptr<const TrackingVolumeArray> containedVolumeArray = nullptr, MutableTrackingVolumeVector denseVolumeVector = {}, const std::string &volumeName = "undefined")

Constructor for a full equipped Tracking Volume.

Parameters:

• transform – is the global 3D transform to position the volume in space

• volumeBounds – is the description of the volume boundaries

• volumeMaterial – is are materials of the tracking volume

• staticLayerArray – is the confined layer array (optional)

• containedVolumeArray – are the sub volumes if the volume is a container

• denseVolumeVector – The contained dense volumes

• volumeName – is a string identifier

TrackingVolume(TrackingVolume&&) noexcept

TrackingVolume(Volume &volume, const std::string &volumeName = "undefined")

Constructor from a regular volume.

Parameters:

• volume – is the volume to be converted

• volumeName – is a string identifier

~TrackingVolume() override

void addPortal(std::shared_ptr<Portal> portal)

Add a portal to this tracking volume.

Parameters:

portal – The portal to add

void addSurface(std::shared_ptr<Surface> surface)

Add a surface to this tracking volume.

Parameters:

surface – The surface to add

TrackingVolume &addVolume(std::unique_ptr<TrackingVolume> volume)

Add a child volume to this tracking volume.

Note

The volume will have its mother volume assigned to this. It will throw if volume already has a mother volume set

Parameters:

volume – The volume to add

Returns:

Reference to the added volume

void assignVolumeMaterial(std::shared_ptr<const IVolumeMaterial> material)

Set the volume material description.

The material is usually derived in a complicated way and loaded from a framework given source. As various volumes could potentially share the the same material description, it is provided as a shared object

Parameters:

material – Material description of this volume

const TrackingVolume *lowestTrackingVolume(const GeometryContext &gctx, const Vector3 &position, const double tol = 0.) const

Return the associated sub Volume, returns THIS if no subVolume exists.

Parameters:

• gctx – The current geometry context object, e.g. alignment

• position – is the global position associated with that search

• tol – Search position tolerance for dense volumes

Returns:

plain pointer to associated with the position

TrackingVolume *motherVolume()

Return the MotherVolume - if it exists.

const TrackingVolume *motherVolume() const

Return the MotherVolume - if it exists.

TrackingVolume &operator=(const TrackingVolume&) = delete

TrackingVolume &operator=(TrackingVolume&&) noexcept

MutablePortalRange portals()

Return mutable view of the registered portals under this tracking volume.

Returns:

the range of portals

PortalRange portals() const

Return all portals registered under this tracking volume.

Returns:

the range of portals

void setMotherVolume(TrackingVolume *mvol)

Set the MotherVolume.

Parameters:

mvol – is the mother volume

void setVolumeName(const std::string &volumeName)

Set the volume name to volumeName.

Parameters:

volumeName – is the new name of

MutableSurfaceRange surfaces()

Return mutable view of the registered surfaces under this tracking volume.

Returns:

the range of surfaces

SurfaceRange surfaces() const

Return all surfaces registered under this tracking volume.

Returns:

the range of surfaces

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor) const

Visit all sensitive surfaces.

Note

If a context is needed for the visit, the vistitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – The callable. Will be called for each sensitive surface that is found, a selection of the surfaces can be done in the visitor

template<SurfaceVisitor visitor_t>
inline void visitSurfaces(visitor_t &&visitor, bool restrictToSensitives) const

Visit all reachable surfaces.

Note

If a context is needed for the visit, the vistitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

• visitor – The callable. Will be called for each reachable surface that is found, a selection of the surfaces can be done in the visitor

• restrictToSensitives – If true, only sensitive surfaces are visited

template<TrackingVolumeVisitor visitor_t>
inline void visitVolumes(visitor_t &&visitor) const

Visit all reachable tracking volumes.

Note

If a context is needed for the visit, the vistitor has to provide this, e.g. as a private member

Template Parameters:

visitor_t – Type of the callable visitor

Parameters:

visitor – The callable. Will be called for each reachable volume that is found, a selection of the volumes can be done in the visitor

const IVolumeMaterial *volumeMaterial() const

Return the material of the volume.

const std::shared_ptr<const IVolumeMaterial> &volumeMaterialPtr() const

Return the material of the volume as shared pointer.

const std::string &volumeName() const

Returns the VolumeName - for debug reason, might be depreciated later.

MutableVolumeRange volumes()

Return mutable view of the registered volumes under this tracking volume.

Returns:

the range of volumes

VolumeRange volumes() const

Return all volumes registered under this tracking volume.

Returns:

the range of volumes

class TrapezoidBounds : public Acts::PlanarBounds

Bounds for a trapezoidal, planar Surface.

Public Types

enum BoundValues

Values:

enumerator eHalfLengthXnegY

enumerator eHalfLengthXposY

enumerator eHalfLengthY

enumerator eRotationAngle

enumerator eSize

Public Functions

TrapezoidBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor for symmetric Trapezoid - from fixed size array.

Parameters:

values – the values to be stream in

TrapezoidBounds(double halfXnegY, double halfXposY, double halfY, double rotAngle = 0.) noexcept(false)

Constructor for symmetric Trapezoid.

Parameters:

• halfXnegY – minimal half length X, definition at negative Y

• halfXposY – maximal half length X, definition at positive Y

• halfY – half length Y - defined at x=0

• rotAngle – rotation angle of the bounds w.r.t coordinate axes

virtual const RectangleBounds &boundingBox() const final

Bounding box parameters.

Returns:

rectangle bounds for a bounding box

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector2 &lposition, const BoundaryTolerance &boundaryTolerance) const final

The orientation of the Trapezoid is according to the figure above, in words: the shorter of the two parallel sides of the trapezoid intersects with the negative \( y \) - axis of the local frame.

The cases are:

(0)

\( y \) or \( x \)

bounds are 0 || 0

(1) the local position is outside

\( y \)

bounds

(2) the local position is inside

\( y \) bounds, but outside maximum \( x \)

bounds

(3) the local position is inside

\( y \) bounds AND inside minimum \( x \)

bounds

(4) the local position is inside

\( y \) bounds AND inside maximum \( x \) bounds, so that it depends on the \( eta \) coordinate (5) the local position fails test of (4)

The inside check is done using single equations of straight lines and one has to take care if a point lies on the positive \( x \) half area(I) or the negative one(II). Denoting \( |x_{min}| \) and \( | x_{max} | \) as minHalfX respectively maxHalfX, such as \( | y_{H} | \) as halfY, the equations for the straing lines in (I) and (II) can be written as:

• (I): \( y = \kappa_{I} x + \delta_{I} \)

• (II): \( y = \kappa_{II} x + \delta_{II} \)

  ,

  where

  \( \kappa_{I} = - \kappa_{II} = 2 \frac{y_{H}}{x_{max} - x_{min}} \) and \( \delta_{I} = \delta_{II} = - \frac{1}{2}\kappa_{I}(x_{max} + x_{min}) \)

Parameters:

• lposition – Local position (assumed to be in right surface frame)

• boundaryTolerance – boundary check directive

Returns:

boolean indicator for the success of this operation

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

Output Method for std::ostream.

Parameters:

sl – is the ostream to be dumped into

inline virtual BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.

Returns:

of the stored values for this SurfaceBounds object

virtual std::vector<Vector2> vertices(unsigned int ignoredSegments = 0u) const final

Return the vertices.

Note

the number of segments is ignored in this representation

Parameters:

ignoredSegments – is and ignored parameter used to describe the number of segments to approximate curved sectors.

Returns:

vector for vertices in 2D

class TrapezoidVolumeBounds : public Acts::VolumeBounds

Bounds for a trapezoidal shaped Volume, the orientedSurface(…) method creates a vector of 6 surfaces:

BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Trazpezoidal Acts::PlaneSurface, parallel to \( xy \) plane at negative \(z\)

• positiveFaceXY [1] : Trazpezoidal Acts::PlaneSurface, parallel to \( xy \) plane at positive \(z\)

• trapezoidFaceAlpha [2] : Rectangular Acts::PlaneSurface, attached to [0] and [1] at negative \(x\) (associated to alpha)

• trapezoidFaceBeta [3] : Rectangular Acts::PlaneSurface, attached to [0] and [1] at positive \( x\) (associated to beta)

• negativeFaceZX [4] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at negative \(y\)

• positiveFaceZX [5] : Rectangular Acts::PlaneSurface, parallel to \( zx \) plane at positive \(y\)

Public Types

enum BoundValues

for access / streaming

Values:

enumerator eHalfLengthXnegY

halflength in x at negative y

enumerator eHalfLengthXposY

halflength in x at positive y

enumerator eHalfLengthY

halflength in y

enumerator eHalfLengthZ

halflength in z

enumerator eAlpha

opening angle alpha (in point A)

enumerator eBeta

opening angle beta (in point B)

enumerator eSize

length of the bounds vector

Public Functions

TrapezoidVolumeBounds() = delete

inline TrapezoidVolumeBounds(const std::array<double, eSize> &values) noexcept(false)

Constructor - from a fixed size array.

Parameters:

values – The bound values

TrapezoidVolumeBounds(const TrapezoidVolumeBounds &trabo) = default

TrapezoidVolumeBounds(double minhalex, double haley, double halez, double alpha, double beta) noexcept(false)

Constructor - the trapezoid boundaries (arbitrary trapezoid)

Parameters:

• minhalex – is the half length in x at minimal y

• haley – is the half length in y

• halez – is the half length in z

• alpha – is the opening angle at -x,-y

• beta – is the opening angle at +x,-y

TrapezoidVolumeBounds(double minhalex, double maxhalex, double haley, double halez) noexcept(false)

Constructor - the trapezoid boundaries (symmetric trapezoid)

Parameters:

• minhalex – is the half length in x at minimal y

• maxhalex – is the half length in x at maximal y

• haley – is the half length in y

• halez – is the half length in z

~TrapezoidVolumeBounds() override = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const final

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline double get(BoundValues bValue) const

Access to the bound values.

Parameters:

bValue – the class nested enum for the array access

virtual bool inside(const Vector3 &pos, double tol = 0.) const override

This method checks if position in the 3D volume frame is inside the cylinder.

Parameters:

• pos – is the global position to be checked

• tol – is the tolerance applied

Returns:

boolean indicator if position is inside

TrapezoidVolumeBounds &operator=(const TrapezoidVolumeBounds &trabo) = default

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const override

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

virtual std::ostream &toStream(std::ostream &os) const override

Output Method for std::ostream.

Parameters:

os – is the output stream

inline virtual VolumeBounds::BoundsType type() const final

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

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

Return the bound values as dynamically sized vector.

Returns:

this returns a copy of the internal values

class TryAllNavigator : public Acts::TryAllNavigatorBase

Alternative Navigator which tries all possible intersections.

See Navigator for more general information about the Navigator concept.

This Navigator tries all possible intersections with all surfaces in the current volume. It does not use any information about the geometry to optimize the search. It is therefore very slow, but can be used as a reference implementation.

Public Types

using Config = TryAllNavigatorBase::Config

using Options = TryAllNavigatorBase::Options

Public Functions

inline TryAllNavigator(Config cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("TryAllNavigator", Logging::INFO))

Constructor with configuration object.

Parameters:

• cfg – The navigator configuration

• logger – a logger instance

inline bool checkTargetValid(const State &state, const Vector3 &position, const Vector3 &direction) const

Check if the target is still valid.

This method checks if the target is valid based on the current position and direction. It returns true if the target is still valid.

For the TryAllNavigator, the target is always invalid since we do not want to assume any specific surface sequence over multiple steps.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

True if the target is still valid

inline const Surface *currentSurface(const State &state) const

inline const TrackingVolume *currentVolume(const State &state) const

inline const IVolumeMaterial *currentVolumeMaterial(const State &state) const

inline bool endOfWorldReached(State &state) const

inline void handleSurfaceReached(State &state, const Vector3 &position, const Vector3 &direction, const Surface&) const

Handle the surface reached.

This method is called when a surface is reached. It sets the current surface in the navigation state and updates the navigation candidates.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

inline Result<void> initialize(State &state, const Vector3 &position, const Vector3 &direction, Direction propagationDirection) const

Initialize the navigator.

This method initializes the navigator for a new propagation. It sets the current volume and surface to the start volume and surface, respectively.

Parameters:

• state – The navigation state

• position – The starting position

• direction – The starting direction

• propagationDirection – The propagation direction

inline State makeState(const Options &options) const

inline bool navigationBreak(const State &state) const

inline NavigationTarget nextTarget(State &state, const Vector3 &position, const Vector3 &direction) const

Get the next target surface.

This method gets the next target surface based on the current position and direction. It returns a none target if no target can be found.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

The next target surface

inline const Surface *startSurface(const State &state) const

inline const Surface *targetSurface(const State &state) const

struct State : public Acts::TryAllNavigatorBase::State

Nested State struct.

Public Functions

inline explicit State(const Options &options_)

Public Members

std::vector<detail::IntersectedNavigationObject> currentCandidates

class TryAllOverstepNavigator : public Acts::TryAllNavigatorBase

Alternative Navigator which tries all possible intersections.

See Navigator for more general information about the Navigator concept.

This Navigator tries all possible intersections with all surfaces in the current volume. It does not use any information about the geometry to optimize the search. It is therefore very slow, but can be used as a reference implementation.

Different to TryAllNavigator, this Navigator discovers intersections by stepping forward blindly and then checking for intersections with all surfaces in the current volume. This is slower, but more robust against bent tracks.

Public Types

using Config = TryAllNavigatorBase::Config

using Options = TryAllNavigatorBase::Options

Public Functions

inline TryAllOverstepNavigator(Config cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("TryAllOverstepNavigator", Logging::INFO))

Constructor with configuration object.

Parameters:

• cfg – The navigator configuration

• logger – a logger instance

inline bool checkTargetValid(const State &state, const Vector3 &position, const Vector3 &direction) const

Check if the target is still valid.

This method checks if the target is valid based on the current position and direction. It returns true if the target is still valid.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

True if the target is still valid

inline const Surface *currentSurface(const State &state) const

inline const TrackingVolume *currentVolume(const State &state) const

inline const IVolumeMaterial *currentVolumeMaterial(const State &state) const

inline bool endOfWorldReached(State &state) const

inline void handleSurfaceReached(State &state, const Vector3 &position, const Vector3 &direction, const Surface&) const

Handle the surface reached.

This method is called when a surface is reached. It sets the current surface in the navigation state and updates the navigation candidates.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

inline Result<void> initialize(State &state, const Vector3 &position, const Vector3 &direction, Direction propagationDirection) const

Initialize the navigator.

This method initializes the navigator for a new propagation. It sets the current volume and surface to the start volume and surface, respectively.

Parameters:

• state – The navigation state

• position – The starting position

• direction – The starting direction

• propagationDirection – The propagation direction

inline State makeState(const Options &options) const

inline bool navigationBreak(const State &state) const

inline NavigationTarget nextTarget(State &state, const Vector3 &position, const Vector3 &direction) const

Get the next target surface.

This method gets the next target surface based on the current position and direction. It returns an invalid target if no target can be found.

Parameters:

• state – The navigation state

• position – The current position

• direction – The current direction

Returns:

The next target surface

inline const Surface *startSurface(const State &state) const

inline const Surface *targetSurface(const State &state) const

struct State : public Acts::TryAllNavigatorBase::State

Nested State struct.

It acts as an internal state which is created for every propagation and meant to keep thread-local navigation information.

Public Functions

inline explicit State(const Options &options_)

inline const detail::IntersectedNavigationObject &activeCandidate() const

Provides easy access to the active intersection candidate.

inline bool endOfCandidates() const

Public Members

int activeCandidateIndex = -1

The current active candidate index of the navigation state.

std::vector<detail::IntersectedNavigationObject> activeCandidates

The vector of active intersection candidates to work through.

std::optional<Vector3> lastPosition

The position before the last step.

class VectorMultiTrajectory : public Acts::detail_vmt::VectorMultiTrajectoryBase, public Acts::MultiTrajectory<VectorMultiTrajectory>

Public Functions

VectorMultiTrajectory() = default

inline VectorMultiTrajectory(const VectorMultiTrajectory &other)

inline VectorMultiTrajectory(VectorMultiTrajectory &&other) noexcept

template<typename T>
inline void addColumn_impl(std::string_view key)

IndexType addTrackState_impl(TrackStatePropMask mask = TrackStatePropMask::All, IndexType iprevious = kInvalid)

void addTrackStateComponents_impl(IndexType istate, TrackStatePropMask mask)

template<typename val_t, typename cov_t> inline void allocateCalibrated_impl (IndexType istate, const Eigen::DenseBase< val_t > &val, const Eigen::DenseBase< cov_t > &cov) requires(Concepts

template<std::size_t measdim>
inline TrackStateProxy::Calibrated<measdim> calibrated_impl(IndexType istate)

template<std::size_t measdim>
inline ConstTrackStateProxy::Calibrated<measdim> calibrated_impl(IndexType istate) const

template<std::size_t measdim>
inline TrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(IndexType istate)

template<std::size_t measdim>
inline ConstTrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(IndexType istate) const

void clear_impl()

inline std::any component_impl(HashedString key, IndexType istate)

inline std::any component_impl(HashedString key, IndexType istate) const

void copyDynamicFrom_impl(IndexType dstIdx, HashedString key, const std::any &srcPtr)

inline TrackStateProxy::Covariance covariance_impl(IndexType parIdx)

inline ConstTrackStateProxy::Covariance covariance_impl(IndexType parIdx) const

inline bool has_impl(HashedString key, IndexType istate) const

inline bool hasColumn_impl(HashedString key) const

inline TrackStateProxy::Covariance jacobian_impl(IndexType istate)

inline ConstTrackStateProxy::Covariance jacobian_impl(IndexType istate) const

inline TrackStateProxy::Parameters parameters_impl(IndexType parIdx)

inline ConstTrackStateProxy::Parameters parameters_impl(IndexType parIdx) const

void reserve(std::size_t n)

inline void setReferenceSurface_impl(IndexType istate, std::shared_ptr<const Surface> surface)

inline void setUncalibratedSourceLink_impl(IndexType istate, SourceLink &&sourceLink)

void shareFrom_impl(IndexType iself, IndexType iother, TrackStatePropMask shareSource, TrackStatePropMask shareTarget)

inline IndexType size_impl() const

inline Statistics statistics() const

void unset_impl(TrackStatePropMask target, IndexType istate)

class Volume : public Acts::GeometryObject

It inherits from GeometryObject for geometry identification.

Base class for all volumes inside the tracking realm, it defines the interface for inherited Volume classes regarding the geometrical information.

Subclassed by Acts::CuboidVolumeStack, Acts::CylinderVolumeStack, Acts::TrackingVolume

Public Types

using BoundingBox = AxisAlignedBoundingBox<Volume, double, 3>

Public Functions

Volume() = delete

Volume(const Transform3 &transform, std::shared_ptr<VolumeBounds> volbounds)

Explicit constructor with shared arguments.

Parameters:

• transform – is the transform to position the volume in 3D space

• volbounds – is the volume boundary definitions

Volume(const Volume &vol, const Transform3 &shift = Transform3::Identity())

Copy Constructor - with optional shift.

Parameters:

• vol – is the source volume for the copy

• shift – is the optional shift applied as : shift * vol.transform()

virtual ~Volume() = default

void assignVolumeBounds(std::shared_ptr<VolumeBounds> volbounds)

Set volume bounds and update volume bounding boxes implicitly.

Parameters:

volbounds – The volume bounds to be assigned

BoundingBox boundingBox(const Vector3 &envelope = {0, 0, 0}) const

Construct bounding box for this shape.

Parameters:

envelope – Optional envelope to add / subtract from min/max

Returns:

Constructed bounding box pointing to this volume

const Vector3 &center() const

returns the center of the volume

bool inside(const Vector3 &gpos, double tol = 0.) const

Inside() method for checks.

Parameters:

• gpos – is the position to be checked

• tol – is the tolerance parameter

Returns:

boolean indicator if the position is inside

const Transform3 &itransform() const

Returns the inverted transform of this volume.

Volume &operator=(const Volume &vol)

Assignment operator.

Parameters:

vol – is the source volume to be copied

bool operator==(const Volume &other) const

BoundingBox orientedBoundingBox() const

Construct oriented bounding box for this shape.

Note

This will build an oriented bounding box with an envelope value of (0.05, 0.05, 0.05)mm

Returns:

Constructed oriented bounding box pointing to this volume

virtual Vector3 referencePosition(const GeometryContext &gctx, AxisDirection aDir) const override

The binning position method.

• as default the center is given, but may be overloaded

Parameters:

• gctx – The current geometry context object, e.g. alignment

• aDir – is the axis direction for the reference position

Returns:

vector 3D that can be used for the binning

void setTransform(const Transform3 &transform)

const Transform3 &transform() const

Return methods for geometry transform.

virtual void update(std::shared_ptr<VolumeBounds> volbounds, std::optional<Transform3> transform = std::nullopt, const Logger &logger = Acts::getDummyLogger())

Set the volume bounds and optionally also update the volume transform.

Parameters:

• volbounds – The volume bounds to be assigned

• transform – The transform to be assigned, can be optional

• logger – A logger object to log messages

void visualize(IVisualization3D &helper, const GeometryContext &gctx, const ViewConfig &viewConfig) const

Produces a 3D visualization of this volume.

Parameters:

• helper – The visualization helper describing the output format

• gctx – The geometry context

• viewConfig – The view configuration

VolumeBounds &volumeBounds()

Returns a mutable reference to the volume bounds.

const VolumeBounds &volumeBounds() const

Returns a const reference to the volume bounds.

std::shared_ptr<VolumeBounds> volumeBoundsPtr()

Returns shared pointer to the volume bounds.

std::shared_ptr<const VolumeBounds> volumeBoundsPtr() const

Returns shared pointer to the volume bounds.

class VolumeBounds

Pure Absract Base Class for Volume bounds.

Acts::VolumeBounds are a set of up to six confining Surfaces that are stored in a std::vector. Each type of Acts::VolumeBounds has to implement a orientedSurfaces() and a inside() method.

The Volume, retrieving a set of Surfaces from the VolumeBounds, can turn the Surfaces into BoundarySurfaces.

Subclassed by Acts::ConeVolumeBounds, Acts::CuboidVolumeBounds, Acts::CutoutCylinderVolumeBounds, Acts::CylinderVolumeBounds, Acts::GenericCuboidVolumeBounds, Acts::TrapezoidVolumeBounds

Public Types

enum class BoundsType

This is nested to the VolumeBounds, as also SurfaceBounds will have Bounds Type.

Values:

enumerator eCone

enumerator eCuboid

enumerator eCutoutCylinder

enumerator eCylinder

enumerator eGenericCuboid

enumerator eTrapezoid

enumerator eOther

Public Functions

VolumeBounds() = default

virtual ~VolumeBounds() = default

virtual Volume::BoundingBox boundingBox(const Transform3 *trf = nullptr, const Vector3 &envelope = {0, 0, 0}, const Volume *entity = nullptr) const = 0

Construct bounding box for this shape.

Parameters:

• trf – Optional transform

• envelope – Optional envelope to add / subtract from min/max

• entity – Entity to associate this bounding box with

Returns:

Constructed bounding box

inline virtual std::vector<AxisDirection> canonicalAxes() const

Get the canonical axis direction that fully describe the shape’s extent.

Note

This is the default implementation that returns the bounding box binning. Individual shapes should override this method

Returns:

vector of canonical axis directions

virtual bool inside(const Vector3 &gpos, double tol = 0.) const = 0

Checking if position given in volume frame is inside.

Parameters:

• gpos – is the global position to be checked

• tol – is the tolerance applied for the inside check

Returns:

boolean indicating if the position is inside

virtual std::vector<OrientedSurface> orientedSurfaces(const Transform3 &transform = Transform3::Identity()) const = 0

Oriented surfaces, i.e.

the decomposed boundary surfaces and the according navigation direction into the volume given the normal vector on the surface

It will throw an exception if the orientation prescription is not adequate

Parameters:

transform – is the 3D transform to be applied to the boundary surfaces to position them in 3D space

Returns:

a vector of surfaces bounding this volume

inline virtual double referenceBorder(AxisDirection aDir) const

Binning borders in double.

Parameters:

aDir – is the binning schema used

Returns:

float offset to be used for the binning

inline virtual Vector3 referenceOffset(AxisDirection aDir) const

Binning offset - overloaded for some R-binning types.

Parameters:

aDir – is the binning schema used

Returns:

vector 3D to be used for the binning

virtual std::ostream &toStream(std::ostream &sl) const = 0

Output Method for std::ostream, to be overloaded by child classes.

Parameters:

sl – is the output stream to be dumped into

virtual BoundsType type() const = 0

Return the bounds type - for persistency optimization.

Returns:

is a BoundsType enum

virtual std::vector<double> values() const = 0

Access method for bound values, this is a dynamically sized vector containing the parameters needed to describe these bounds.

Returns:

of the stored values for this SurfaceBounds object

Public Static Attributes

static const std::vector<std::string> s_boundsTypeNames

Static member to get the name of the BoundsType.

Enums

enum class Acts::AxisBoundaryType

Enum which determines how the axis handle its outer boundaries possible values values.

Values:

enumerator Open

Default behaviour: out of bounds positions are filled into the over or underflow bins.

enumerator Bound

Out-of-bounds positions resolve to first/last bin respectively.

enumerator Closed

Out-of-bounds positions resolve to the outermost bin on the opposite side.

enum class Acts::AxisDirection : int

to specify a local axis direction

Values:

enumerator AxisX

AxisX, AxisY, AxisZ are the cartesian directions in the local frame.

enumerator AxisY

enumerator AxisZ

enumerator AxisR

AxisR is a radial direction.

enumerator AxisPhi

AxisPhi is the azimuthal direction.

enumerator AxisRPhi

AxisRPhi is the radial-azimuthal direction.

enumerator AxisTheta

AxisTheta is the polar angle direction.

enumerator AxisEta

AxisEta is the pseudorapidity direction.

enumerator AxisMag

AxisMag is the magnitude of the vector.

enum class Acts::AxisType

Enum which determines the binning type of the axis.

Values:

enumerator Equidistant

An axis where all bins have the same size.

enumerator Variable

An axis where bins can have different sizes.

enum Acts::BinningType

, BinningOption & BinningAccess

• BinningType:

  Enumeration to qualify the binning type for the use of the LayerArrayCreator and the TrackingVolumeArrayCreator

  • BinningOption: open: [0,max] closed: 0 -> nextbin -> max -> 0

  • AxisDirection necessary access to global positions

Values:

enumerator equidistant

enumerator arbitrary

enum Acts::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 class Acts::ComponentMergeMethod

Available reduction methods for the reduction of a Gaussian mixture.

Values:

enumerator eMean

enumerator eMaxWeight

enum Acts::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 class Acts::MagneticFieldError

Values:

enumerator OutOfBounds

enumerator NotImplemented

enum class Acts::TrackStatePropMask : std::uint8_t

Collection of bit masks to enable steering which components of a track state should be initialized, and which should be left invalid.

These mask values can be combined using binary operators, so (TrackStatePropMask::Predicted | TrackStatePropMask::Jacobian) will instruct allocating storage for both predicted parameters (including covariance) and a jacobian. The enum is used as a strong type wrapper around the bits to prevent autoconversion from integer

Values:

enumerator None

enumerator Predicted

enumerator Filtered

enumerator Smoothed

enumerator Jacobian

enumerator Calibrated

enumerator All

Functions

inline const Logger &Acts::CylinderVolumeBuilder::logger() const

Private access to the logger.

Returns:

a const reference to the logger

std::unique_ptr<const TrackingGeometry> Acts::convertDD4hepDetector(dd4hep::DetElement worldDetElement, const Logger &logger, 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, std::shared_ptr<const GeometryIdentifierHook> geometryIdentifierHook = std::make_shared<GeometryIdentifierHook>())

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

• logger – [in] A logger instance 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 hierarchies need to be sorted ascending. The default is sorting by ID.

• gctx – The geometry context to use

• matDecorator – is the material decorator that loads material maps

• geometryIdentifierHook – Hook to apply to surfaces during geometry closure.

Throws:

std::logic_error – if an error in the translation occurs

Pre:

Before using this method make sure, that the preconditions described in DD4hepPlugins are met.

Returns:

std::unique_ptr to the full TrackingGeometry

• The Tracking geometry needs to be built from bottom to top to ensure Navigation. Therefore the different hierarchies 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

std::unique_ptr<const Logger> Acts::getDefaultLogger(const std::string &name, const Logging::Level &lvl, std::ostream *log_stream = &std::cout)

get default debug output logger

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

const Logger &Acts::getDummyLogger()

AtlasBetheHeitlerApprox<6, 5> Acts::makeDefaultBetheHeitlerApprox(bool clampToRange = false)

Creates a AtlasBetheHeitlerApprox object based on an ATLAS configuration, that are stored as static data in the source code.

This may not be an optimal configuration, but should allow to run the GSF without the need to load files

void Acts::reduceMixtureLargestWeights(std::vector<Acts::GsfComponent> &cmpCache, std::size_t maxCmpsAfterMerge, const Surface &surface)

Very simple mixture reduction method: Just removes the components with the smallest weight until the required number of components is reached.

Parameters:

• cmpCache – the component collection

• maxCmpsAfterMerge – the number of components we want to reach

• surface – the surface type on which the components are (unused here)

void Acts::reduceMixtureWithKLDistance(std::vector<GsfComponent> &cmpCache, std::size_t maxCmpsAfterMerge, const Surface &surface)

Greedy component reduction algorithm.

Reduces the components with the minimal symmetric KL-distance (applied only to the q/p-dimension) until the required number of components is reached.

Parameters:

• cmpCache – the component collection

• maxCmpsAfterMerge – the number of components we want to reach

• surface – the surface type on which the components are

Structs

Warning

doxygenstruct: Cannot find class “Acts::ActorList” in doxygen xml output for project “Acts” from directory: _build/doxygen-xml

template<typename track_container_t>
struct CombinatorialKalmanFilterExtensions

Extension struct which holds the delegates to customize the CKF behavior.

Public Types

using BranchStopper = Delegate<BranchStopperResult(const TrackProxy&, const TrackStateProxy&)>

using BranchStopperResult = CombinatorialKalmanFilterBranchStopperResult

using TrackProxy = typename track_container_t::TrackProxy

using TrackStateCreator = Delegate<Result<CkfTypes::BranchVector<TrackIndexType>>(const GeometryContext &geoContext, const CalibrationContext &calibrationContext, const Surface &surface, const CkfTypes::BoundState &boundState, TrackIndexType prevTip, std::vector<TrackStateProxy> &trackStateCandidates, traj_t &trajectory, const Logger &logger)>

Delegate the extension of the trajectory onto the given surface to an external unit.

Note

Expected to create track states for measurements associated to the given surface which match the given bound state. Moreover the The “filtered” data is not expected to be set, but the outlier flag should be set for states that are considered to be outlier.

Param geoContext:

The current geometry context

Param calibrationContext:

pointer to the current calibration context

Param surface:

the surface at which new track states are to be created

Param boundState:

the current bound state of the trajectory

Param prevTip:

Index pointing at previous trajectory state (i.e. tip)

Param trackStateCandidates:

a temporary buffer that can be used to collect track states

Param trajectory:

the trajectory to which the new states are to be added

Param logger:

a logger for messages

Return:

indices of new track states which extend the trajectory given by prevTip

using TrackStateProxy = typename track_container_t::TrackStateProxy

using traj_t = typename track_container_t::TrackStateContainerBackend

using Updater = typename KalmanFitterExtensions<traj_t>::Updater

Public Members

BranchStopper branchStopper = {DelegateFuncTag<voidBranchStopper>{}}

The branch stopper is called during the filtering by the Actor.

TrackStateCreator createTrackStates

The delegate to create new track states.

Note

a reference implementation can be found in TrackStateCreator which makes uses of MeasurementSelector and SourceLinkAccessor

Updater updater = {DelegateFuncTag<detail::voidFitterUpdater<traj_t>>{}}

The updater incorporates measurement information into the track parameters.

template<typename track_container_t>
struct CombinatorialKalmanFilterOptions

Combined options for the combinatorial Kalman filter.

Template Parameters:

• source_link_iterator_t – Type of the source link iterator

• track_container_t – Type of the track container

Public Types

using TrackStateContainerBackend = typename track_container_t::TrackStateContainerBackend

using TrackStateProxy = typename track_container_t::TrackStateProxy

Public Functions

CombinatorialKalmanFilterOptions() = delete

Contexts are required and the options must not be default-constructible.

inline CombinatorialKalmanFilterOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx, std::reference_wrapper<const CalibrationContext> cctx, CombinatorialKalmanFilterExtensions<track_container_t> extensions_, const PropagatorPlainOptions &pOptions, bool mScattering = true, bool eLoss = true)

PropagatorOptions with context.

Parameters:

• gctx – The geometry context for this track finding/fitting

• mctx – The magnetic context for this track finding/fitting

• cctx – The calibration context for this track finding/fitting

• extensions_ – The extension struct

• pOptions – The plain propagator options

• mScattering – Whether to include multiple scattering

• eLoss – Whether to include energy loss

Public Members

std::reference_wrapper<const CalibrationContext> calibrationContext

context object for the calibration

bool energyLoss = true

Whether to consider energy loss.

CombinatorialKalmanFilterExtensions<track_container_t> extensions

The filter extensions.

std::reference_wrapper<const GeometryContext> geoContext

Context object for the geometry.

std::reference_wrapper<const MagneticFieldContext> magFieldContext

Context object for the magnetic field.

bool multipleScattering = true

Whether to consider multiple scattering.

PropagatorPlainOptions propagatorPlainOptions

The trivial propagator options.

bool skipPrePropagationUpdate = false

Skip the pre propagation call.

This effectively skips the first surface

Note

This is useful if the first surface should not be considered in a second reverse pass

const Surface *targetSurface = nullptr

The target surface.

Note

This is useful if the filtering should be terminated at a certain surface

struct State

Nested State struct.

It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information

Public Functions

inline explicit State(const Options &options_)

inline bool endOfSurfaces() const

inline const Surface &navSurface() const

inline void nextSurface()

inline int remainingSurfaces() const

inline void resetSurfaceIndex()

Public Members

const Surface *currentSurface = nullptr

Navigation state - external interface: the current surface.

Direction direction = Direction::Forward()

bool navigationBreak = false

Navigation state - external interface: a break has been detected.

Options options

NavigatorStatistics statistics

Navigation statistics.

int surfaceIndex = -1

Index of the next surface to try.

Note

-1 means before the first surface in the sequence and size() means after the last surface in the sequence

struct EigenStepperDefaultExtension

Default evaluator of the k_i’s and elements of the transport matrix D of the RKN4 stepping.

This is a pure implementation by textbook.

struct EigenStepperDenseExtension

Evaluator of the k_i’s and elements of the transport matrix D of the RKN4 stepping.

This implementation involves energy loss due to ionisation, bremsstrahlung, pair production and photonuclear interaction in the propagation and the Jacobian. These effects will only occur if the propagation is in a TrackingVolume with attached material.

Public Members

double currentMomentum = 0.

Momentum at a certain point.

EigenStepperDefaultExtension defaultExtension

Fallback extension.

double dgdqopValue = 0.

Derivative d(dEds)d(q/p) evaluated at the initial point.

std::array<double, 4> dLdl = {}

Derivatives dLambda’’dlambda at each sub-step point.

std::array<double, 4> dPds = {}

Derivatives dPds at each sub-step.

std::array<double, 4> energy = {}

Energy at each sub-step.

double g = 0.

Derivative dEds at the initial point.

double initialMomentum = 0.

Particles momentum at k1.

std::array<double, 4> Lambdappi = {}

Lambda’’_i.

Material material

Material that will be passed TODO : Might not be needed anymore.

std::array<double, 4> qop = {}

q/p at each sub-step

std::array<double, 4> tKi = {}

k_i equivalent for the time propagation

struct NavigationState

A navigation state struct that is holding the current navigation information.

It relies on Surfaces and Portals, all navigation entities have to be described in these terms.

Subclassed by Acts::Experimental::DetectorNavigator::State

Public Types

using SurfaceCandidates = std::vector<SurfaceCandidate>

Surface candidate vector alias, this allows to use e.g.

boost_small vector or other stl like containers

Public Functions

inline const SurfaceCandidate &surfaceCandidate() const

Public Members

std::any auxiliary

Auxiliary attached information.

const Detector *currentDetector = nullptr

The current detector in processing.

const Portal *currentPortal = nullptr

The current portal, i.e the position is on portal.

const Surface *currentSurface = nullptr

The current surface, i.e the position is on surface.

const DetectorVolume *currentVolume = nullptr

The current volume in processing, i.e. the position is inside.

Vector3 direction = Vector3(0., 0., 0.)

The current direction.

double overstepTolerance = -100 * UnitConstants::um

An overstep tolerance.

Vector3 position = Vector3(0., 0., 0.)

The current position.

BoundaryTolerance surfaceBoundaryTolerance = BoundaryTolerance::None()

Boundary directives for surfaces.

std::size_t surfaceCandidateIndex = 0

SurfaceCandidates surfaceCandidates = {}

That are the candidate surfaces to process.

struct SurfaceCandidate

A surface candidate and its intersection.

A candidates can either be a surface or a portal (which contain a surface)

Public Members

BoundaryTolerance boundaryTolerance = BoundaryTolerance::None()

The boundary check used for the candidate, boundary checks can differ for sensitive surfaces and portals.

ObjectIntersection<Surface> objectIntersection

A candidate intersection, in Surface view.

const Portal *portal = nullptr

Or a portal.

const Surface *surface = nullptr

A candidate is either a detector Surface.

template<typename propagator_t, typename bethe_heitler_approx_t, typename traj_t>
struct GaussianSumFitter

Gaussian Sum Fitter implementation.

Note

This GSF implementation tries to be as compatible to the KalmanFitter as possible. However, strict compatibility is not garantueed.

Note

Currently there is no possibility to export the states of the individual components from the GSF, the only information returned in the MultiTrajectory are the means of the states. Therefore, also NO dedicated component smoothing is performed as described e.g. by R. Fruewirth.

Template Parameters:

• propagator_t – The propagator type on which the algorithm is built on

• bethe_heitler_approx_t – The type of the Bethe-Heitler-Approximation

• traj_t – The MultiTrajectory type (backend)

Public Types

using GsfActor = detail::GsfActor<bethe_heitler_approx_t, traj_t>

The actor type.

using GsfNavigator = typename propagator_t::Navigator

The navigator type.

Public Functions

inline GaussianSumFitter(propagator_t &&propagator, bethe_heitler_approx_t &&bha, std::unique_ptr<const Logger> _logger = getDefaultLogger("GSF", Logging::INFO))

template<typename source_link_it_t, typename start_parameters_t, TrackContainerFrontend track_container_t>
inline auto fit(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, const std::vector<const Surface*> &sSequence, track_container_t &trackContainer) const

The fit function for the Direct navigator.

template<typename source_link_it_t, typename start_parameters_t, TrackContainerFrontend track_container_t>
inline auto fit(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, track_container_t &trackContainer) const

The fit function for the standard navigator.

template<typename source_link_it_t, typename start_parameters_t, typename fwd_prop_initializer_t, typename bwd_prop_initializer_t, TrackContainerFrontend track_container_t>
inline Acts::Result<typename track_container_t::TrackProxy> fit_impl(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, const fwd_prop_initializer_t &fwdPropInitializer, const bwd_prop_initializer_t &bwdPropInitializer, track_container_t &trackContainer) const

The generic implementation of the fit function.

TODO check what this function does with the referenceSurface is e.g. the first measurementSurface

inline const Logger &logger() const

Public Members

std::unique_ptr<const Logger> m_actorLogger

bethe_heitler_approx_t m_betheHeitlerApproximation

The fitter holds the instance of the bethe heitler approx.

std::unique_ptr<const Logger> m_logger

The logger.

propagator_t m_propagator

The propagator instance used by the fit function.

struct AllSelector : public Acts::IGeant4PhysicalVolumeSelector

Struct that selects all G4VPhysicalVolume objects.

Public Functions

inline virtual bool select(const G4VPhysicalVolume&) const final

The main interface method.

Parameters:

g4Phys – the physical volume to be checked

Returns:

a boolean indicating if it should be selected or not

struct NameSelector : public Acts::IGeant4PhysicalVolumeSelector

Struct that selects G4VPhysicalVolume objects that match one of the provided names, exact or partially.

Public Functions

inline NameSelector(const std::vector<std::string> &ns, bool e = false)

Constructor with arguments.

Parameters:

• ns – the provided list of names

• e – whether to select them exact or not

virtual bool select(const G4VPhysicalVolume &g4PhysVol) const final

Secect function for the volume.

Parameters:

g4PhysVol – the volume that is checked

Returns:

a boolean indicating the selection

Public Members

bool exact = false

std::vector<std::string> names = {}

struct PositionSelector : public Acts::IGeant4PhysicalVolumeSelector

Struct that selects G4VPhysicalVolume objects based on the allowed range of their position.

Note

Can be used for preselection of volumes before a KDTree search. This way the memory consumption can be reduced, compromising the execution speed

Note

Careful with axis conventions as Geant4 uses a different one than Acts

Public Functions

inline explicit PositionSelector(const std::map<unsigned int, std::tuple<double, double>> &ranges)

Constructor with arguments.

Parameters:

ranges – the provided map of axes of ranges

virtual bool select(const G4VPhysicalVolume &g4PhysVol) const final

Secect function for the volume.

Parameters:

g4PhysVol – the volume that is checked

Returns:

a boolean indicating the selection

Public Members

std::map<unsigned int, std::tuple<double, double>> m_ranges

template<typename traj_t>
struct GsfOptions

Public Functions

inline GsfOptions(const GeometryContext &geoCtxt, const MagneticFieldContext &magFieldCtxt, const CalibrationContext &calibCtxt)

Public Members

bool abortOnError = false

std::reference_wrapper<const CalibrationContext> calibrationContext

ComponentMergeMethod componentMergeMethod = ComponentMergeMethod::eMaxWeight

bool disableAllMaterialHandling = false

GsfExtensions<traj_t> extensions

std::string_view finalMultiComponentStateColumn = ""

std::reference_wrapper<const GeometryContext> geoContext

std::reference_wrapper<const MagneticFieldContext> magFieldContext

std::size_t maxComponents = 4

PropagatorPlainOptions propagatorPlainOptions

const Surface *referenceSurface = nullptr

double weightCutoff = 1.e-4

struct MultiStepperSurfaceReached : public Acts::ForcedSurfaceReached

Public Functions

MultiStepperSurfaceReached() = default

template<typename propagator_state_t, typename stepper_t, typename navigator_t>
inline bool checkAbort(propagator_state_t &state, const stepper_t &stepper, const navigator_t &navigator, const Logger &logger) const

boolean operator for abort condition without using the result

Template Parameters:

• propagator_state_t – Type of the propagator state

• stepper_t – Type of the stepper

• navigator_t – Type of the navigator

Parameters:

• state – [inout] The propagation state object

• stepper – [in] Stepper used for propagation

• navigator – [in] Navigator used for the propagation

• logger – a logger instance

Public Members

bool averageOnSurface = true

If this is set, we are also happy if the mean of the components is on the surface.

How the averaging is performed depends on the stepper implementation

double averageOnSurfaceTolerance = 0.2

A configurable tolerance within which distance to the intersection we consider the surface as reached.

Has no effect if averageOnSurface is false

struct State

Nested State struct.

It acts as an internal state which is created for every propagation and meant to keep thread-local navigation information.

Public Functions

inline explicit State(const Options &options_)

inline BoundaryIntersection &navBoundary()

inline LayerIntersection &navLayer()

inline SurfaceIntersection &navSurface()

inline void reset()

inline void resetAfterLayerSwitch()

inline void resetAfterVolumeSwitch()

Public Members

const Layer *currentLayer = nullptr

const Surface *currentSurface = nullptr

const TrackingVolume *currentVolume = nullptr

NavigationBoundaries navBoundaries = {}

the vector of boundary surfaces to work through

std::optional<std::size_t> navBoundaryIndex

the current boundary index of the navigation state

bool navigationBreak = false

Stage navigationStage = Stage::initial

std::optional<std::size_t> navLayerIndex

the current layer index of the navigation state

NavigationLayers navLayers = {}

the vector of navigation layers to work through

std::optional<std::size_t> navSurfaceIndex

the current surface index of the navigation state

NavigationSurfaces navSurfaces = {}

the vector of navigation surfaces to work through

Options options

const Layer *startLayer = nullptr

const Surface *startSurface = nullptr

const TrackingVolume *startVolume = nullptr

NavigatorStatistics statistics

const Surface *targetSurface = nullptr

struct Neutral

Charge and momentum interpretation for neutral particles.

Public Functions

constexpr Neutral() = default

inline constexpr Neutral(float absQ) noexcept

Construct and verify the input charge magnitude (in debug builds).

This constructor is only provided to allow consistent construction.

inline constexpr float absQ() const noexcept

inline constexpr float extractCharge(double) const noexcept

inline constexpr double extractMomentum(double qOverP) const noexcept

inline constexpr double qOverP(double momentum, float signedQ) const noexcept

Friends

inline friend constexpr friend bool operator== (Neutral, Neutral) noexcept

Compare for equality.

This is always true as Neutral has no internal state. Must be available to provide a consistent interface.

struct OrientedSurface

Public Members

Direction direction = Direction::AlongNormal()

std::shared_ptr<RegularSurface> surface

struct PathLimitReached

This is the condition that the pathLimit has been reached.

Public Functions

template<typename propagator_state_t, typename stepper_t, typename navigator_t>
inline bool checkAbort(propagator_state_t &state, const stepper_t &stepper, const navigator_t &navigator, const Logger &logger) const

boolean operator for abort condition without using the result

Template Parameters:

• propagator_state_t – Type of the propagator state

• stepper_t – Type of the stepper

• navigator_t – Type of the navigator

Parameters:

• state – [inout] The propagation state object

• stepper – [in] Stepper used for propagation

• navigator – [in] Navigator used for propagation

• logger – a logger instance

Public Members

double internalLimit = std::numeric_limits<double>::max()

Boolean switch for Loop protection.

template<typename stepper_options_t, typename navigator_options_t, typename actor_list_t = ActorList<>>
struct PropagatorOptions : public Acts::detail::PurePropagatorPlainOptions

Options for propagate() call.

Template Parameters:

actor_list_t – List of action types called after each propagation step with the current propagation and stepper state

Public Types

using actor_list_type = actor_list_t

using navigator_options_type = navigator_options_t

using stepper_options_type = stepper_options_t

Public Functions

inline PropagatorOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx)

PropagatorOptions with context.

inline PropagatorOptions(const PropagatorPlainOptions &pOptions)

PropagatorOptions with context and plain options.

template<typename extended_actor_list_t>
inline PropagatorOptions<stepper_options_t, navigator_options_t, extended_actor_list_t> extend(extended_actor_list_t extendedActorList) const

Expand the options with extended actors.

Template Parameters:

extended_actor_list_t – Type of the new actor list

Parameters:

extendedActorList – The new actor list to be used (internally)

inline operator PropagatorPlainOptions() const

Convert to plain options.

inline void setPlainOptions(const PropagatorPlainOptions &pOptions)

Set the plain options.

Parameters:

pOptions – The plain options

Public Members

actor_list_t actorList

List of actions.

std::reference_wrapper<const GeometryContext> geoContext

The context object for the geometry.

std::reference_wrapper<const MagneticFieldContext> magFieldContext

The context object for the magnetic field.

navigator_options_t navigation

Navigator options.

stepper_options_t stepping

Stepper options.

struct PropagatorPlainOptions : public Acts::detail::PurePropagatorPlainOptions

Holds the generic propagator options.

Public Functions

inline PropagatorPlainOptions(const GeometryContext &gctx, const MagneticFieldContext &mctx)

PropagatorPlainOptions with context.

Public Members

std::reference_wrapper<const GeometryContext> geoContext

The context object for the geometry.

std::reference_wrapper<const MagneticFieldContext> magFieldContext

The context object for the magnetic field.

NavigatorPlainOptions navigation

Navigator plain options.

StepperPlainOptions stepping

Stepper plain options.

struct ProtoDetector

A proto detector description being used to define an overall structure of either a TrackingGeometry or Experimental::Detector.

Public Functions

inline void harmonize(bool legacy = true)

Harmonize the detector information, this can run in two modes, steered by the.

The legacy mode prepares everything for Acts::TrackingVolume, if off it creates a description for Acts::Detector.

Parameters:

legacy – boolean

std::string toString(const std::string &indent = "") const

Write the tracking volume to screen.

Parameters:

indent – the current indentation

Public Members

std::string name = ""

ProtoVolume worldVolume

struct SeedConfirmationRangeConfig

Contains parameters for quality seed confirmation.

Note

Requirements on the number of compatible space-points and impact parameters can be defined for different (r, z) regions of the detector (e.g. forward or central region) by SeedConfirmationRange. Seeds are classified as “high-quality” seeds and normal quality seeds. Normal quality seeds are only selected if no other “high-quality” seed has been found for that inner-middle doublet. For optimization reasons, the algorithm only calls the seed confirmation for a certain inner-middle doublet, in case a configurable minimum number of inner-middle-outer triplets have been found.

Public Members

float minImpactSeedConf = 1. * Acts::UnitConstants::mm

Minimum impact parameter of seed required in quality seed confirmation.

std::size_t nTopForLargeR = 0

Minimum number of compatible outer space-points required in quality seed confirmation if inner space-points radius is larger than rMaxSeedConf.

std::size_t nTopForSmallR = 0

Minimum number of compatible outer space-points required in quality seed confirmation if inner space-points radius is smaller than rMaxSeedConf.

float rMaxSeedConf = std::numeric_limits<float>::max()

Radius position of inner seed component that is used to split the region of the detector for seed confirmation.

float seedConfMaxZOrigin = 150. * Acts::UnitConstants::mm

Maximum longitudinal impact parameter of seed required in quality seed confirmation.

float seedConfMinBottomRadius = 60. * Acts::UnitConstants::mm

Minimum radius for inner seed component required in quality seed confirmation.

float zMaxSeedConf = std::numeric_limits<float>::max()

Maximum z position of middle component of the seed used to split the region of the detector for seed confirmation.

float zMinSeedConf = std::numeric_limits<float>::lowest()

Minimum z position of middle component of the seed used to split the region of the detector for seed confirmation.

struct SinglyCharged

Charge and momentum interpretation for particles with +-e charge.

Public Functions

constexpr SinglyCharged() = default

inline constexpr SinglyCharged(float absQ) noexcept

Construct and verify the input charge magnitude (in debug builds).

This constructor is only provided to allow consistent construction.

inline constexpr float absQ() const noexcept

inline constexpr float extractCharge(double qOverP) const noexcept

inline constexpr double extractMomentum(double qOverP) const noexcept

inline constexpr double qOverP(double momentum, float signedQ) const noexcept

Friends

inline friend constexpr friend bool operator== (SinglyCharged, SinglyCharged) noexcept

Compare for equality.

This is always true as SinglyCharged has no internal state. Must be available to provide a consistent interface.

template<typename source_link_iterator_t, typename track_container_t>
struct TrackStateCreator

Create track states for selected measurements associated to a surface.

• First get a source link range covering relevant measurements associated to the given surface. This task is delegated to a SourceLinkAccessor.

• Then create temporary track states for all measurements defined by a source link range, calibrate the measurements and fill the the calibrated data of these track states using a dedicated calibrator

• The measurement selection is delegated to a dedicated measurement selector.

• Finally add branches to the given trajectory for the selected, temporary track states. The track states of these branches still lack the filtered data which is to be filled by the next stage e.g. the CombinatorialKalmanFilter. All track states, the temporary track states and track states for selected measurements, are created in the given trajectory. The resulting container may become big. Thus, it is advisable to copy selected tracks and their track states to a separate container after each track finding step.

Public Types

using BoundState = std::tuple<BoundTrackParameters, BoundMatrix, double>

using Calibrator = typename KalmanFitterExtensions<TrackStateContainerBackend>::Calibrator

using candidate_container_t = typename std::vector<typename track_container_t::TrackStateProxy>

using MeasurementSelector = Delegate<Result<std::pair<typename candidate_container_t::iterator, typename candidate_container_t::iterator>>(candidate_container_t &trackStates, bool&, const Logger&)>

using SourceLinkAccessor = Delegate<std::pair<source_link_iterator_t, source_link_iterator_t>(const Surface&)>

using TrackProxy = typename track_container_t::TrackProxy

using TrackStateContainerBackend = typename track_container_t::TrackStateContainerBackend

using TrackStateProxy = typename track_container_t::TrackStateProxy

using TrackStatesResult = Acts::Result<CkfTypes::BranchVector<TrackIndexType>>

Public Functions

inline Result<CkfTypes::BranchVector<TrackIndexType>> createSourceLinkTrackStates(const GeometryContext &gctx, const CalibrationContext &calibrationContext, [[maybe_unused]] const Surface &surface, const BoundState &boundState, source_link_iterator_t slBegin, source_link_iterator_t slEnd, TrackIndexType prevTip, std::vector<TrackStateProxy> &trackStateCandidates, TrackStateContainerBackend &trajectory, const Logger &logger) const

Create track states for selected measurements given by the source links.

Parameters:

• gctx – The current geometry context

• calibrationContext – pointer to the current calibration context

• surface – the surface the sourceLinks are associated to

• boundState – Bound state from the propagation on this surface

• slBegin – Begin iterator for sourceLinks

• slEnd – End iterator for sourceLinks

• prevTip – Index pointing at previous trajectory state (i.e. tip)

• trackStateCandidates – a temporary buffer which can be used to to keep track of newly created temporary track states.

• trajectory – the trajectory to which new track states for selected measurements will be added

• logger – the logger for messages.

inline Result<CkfTypes::BranchVector<TrackIndexType>> createTrackStates(const GeometryContext &gctx, const CalibrationContext &calibrationContext, [[maybe_unused]] const Surface &surface, const BoundState &boundState, TrackIndexType prevTip, std::vector<TrackStateProxy> &trackStateCandidates, TrackStateContainerBackend &trajectory, const Logger &logger) const

extend the trajectory onto the given surface.

Extend or branch the trajectory onto the given surface. This may create new track states using measurements which match the predicted bound state. This may create multiple branches. The new track states still miss the “filtered” data.

Parameters:

• gctx – The geometry context to be used for this task

• calibrationContext – The calibration context used to fill the calibrated data

• surface – The surface onto which the trajectory is extended

• boundState – the predicted bound state on the given surface

• prevTip – the tip of the trajectory which is to be extended

• trackStateCandidates – a temporary buffer which can be used to to keep track of newly created temporary track states.

• trajectory – the trajectory to be extended.

• logger – a logger for messages.

Returns:

a list of indices of newly created track states which extend the trajectory onto the given surface and match the bound state, or an error.

inline Result<CkfTypes::BranchVector<TrackIndexType>> processSelectedTrackStates(typename std::vector<TrackStateProxy>::const_iterator begin, typename std::vector<TrackStateProxy>::const_iterator end, TrackStateContainerBackend &trackStates, bool isOutlier, const Logger &logger) const

Create track states for the given trajectory from candidate track states.

Parameters:

• begin – begin iterator of the list of candidate track states

• end – end iterator of the list of candidate track states

• trackStates – the trajectory to which the new track states are added

• isOutlier – true if the candidate(s) is(are) an outlier(s).

• logger – the logger for messages

Public Members

Calibrator calibrator = {DelegateFuncTag<detail::voidFitterCalibrator<TrackStateContainerBackend>>{}}

The Calibrator is a dedicated calibration algorithm that allows to calibrate measurements using track information, this could be e.g.

sagging for wires, module deformations, etc.

MeasurementSelector measurementSelector = {DelegateFuncTag<voidMeasurementSelector>{}}

SourceLinkAccessor sourceLinkAccessor

The source link accessor will return an source link range for a surface which link to the associated measurements.

Public Static Functions

static inline Result<std::pair<typename std::vector<TrackStateProxy>::iterator, typename std::vector<TrackStateProxy>::iterator>> voidMeasurementSelector(typename std::vector<TrackStateProxy> &candidates, bool&, const Logger&)

Default measurement selector which will return all measurements.

Parameters:

candidates – Measurement track state candidates

Types

template<unsigned int kRows, unsigned int kCols>
using Acts::ActsMatrix = Eigen::Matrix<double, kRows, kCols>

template<unsigned int kSize>
using Acts::ActsSquareMatrix = Eigen::Matrix<double, kSize, kSize>

template<unsigned int kSize>
using Acts::ActsVector = Eigen::Matrix<double, kSize, 1>

using Acts::AngleAxis3 = Eigen::AngleAxis<double>

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

using Acts::BoundSquareMatrix = ActsSquareMatrix<eBoundSize>

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

using Acts::BoundTrackParameters = GenericBoundTrackParameters<ParticleHypothesis>

BoundTrackParameters can hold any kind of charge.

using Acts::BoundVector = ActsVector<eBoundSize>

using Acts::BoundarySurface = BoundarySurfaceT<TrackingVolume>

BoundarySurface of a volume.

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

using Acts::FreeSquareMatrix = ActsSquareMatrix<eFreeSize>

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

using Acts::FreeToPathMatrix = ActsMatrix<1, eFreeSize>

using Acts::FreeVector = ActsVector<eFreeSize>

using Acts::HashedString = std::uint32_t

using Acts::Intersection3D = Intersection<3>

typedef BinnedArray<LayerPtr> Acts::LayerArray

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

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

using Acts::MaxWeightReducerLoop = detail::SingleComponentReducer<detail::MaxWeightComponent>

using Acts::RotationMatrix2 = SquareMatrix2

using Acts::RotationMatrix3 = SquareMatrix3

using Acts::SquareMatrix2 = ActsSquareMatrix<2>

using Acts::SquareMatrix3 = ActsSquareMatrix<3>

using Acts::SquareMatrix4 = ActsSquareMatrix<4>

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

using Acts::Transform2 = Eigen::Transform<double, 2, Eigen::AffineCompact>

using Acts::Transform3 = Eigen::Transform<double, 3, Eigen::Affine>

using Acts::Translation2 = Eigen::Translation<double, 2>

using Acts::Translation3 = Eigen::Translation<double, 3>

using Acts::Vector2 = ActsVector<2>

using Acts::Vector3 = ActsVector<3>

using Acts::Vector4 = ActsVector<4>