Class AtlasStepper

Nested Relationships

Nested Types

Class Documentation

class Acts::AtlasStepper

the AtlasStepper implementation for the

Public Types

using BoundState = std::tuple<BoundTrackParameters, Jacobian, double>
using Covariance = BoundSymMatrix
using CurvilinearState = std::tuple<CurvilinearTrackParameters, Jacobian, double>
using Jacobian = BoundMatrix

Public Functions

AtlasStepper(std::shared_ptr<const MagneticFieldProvider> bField)
Result<BoundState> boundState(State &state, const Surface &surface, bool transportCov = true) const

Create and return the bound state at the current position.

Return

A bound state:

  • the parameters at the surface

  • the stepwise jacobian towards it

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

Parameters

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

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

  • [in] transportCov: Flag steering covariance transport

double charge(const State &state) const

Charge access.

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

Create and return a curvilinear state at the current position.

Return

A curvilinear state:

  • the curvilinear parameters at given position

  • the stepweise jacobian towards it

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

Parameters

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

  • [in] transportCov: Flag steering covariance transport

Vector3 direction(const State &state) const
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

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

  • [in] pos: is the field position

template<typename charge_t>
State makeState(std::reference_wrapper<const GeometryContext> gctx, std::reference_wrapper<const MagneticFieldContext> mctx, const SingleBoundTrackParameters<charge_t> &par, NavigationDirection ndir = forward, double ssize = std::numeric_limits<double>::max(), double stolerance = s_onSurfaceTolerance) const
double momentum(const State &state) const
std::string outputStepSize(const State &state) const

Output the Step Size - single component.

Parameters

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

double overstepLimit(const State&) const

Overstep limit.

Parameters

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

Vector3 position(const State &state) const
void releaseStepSize(State &state) const

Release the Step size.

Parameters

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

void resetState(State &state, const BoundVector &boundParams, const BoundSymMatrix &cov, const Surface &surface, const NavigationDirection navDir = forward, const double stepSize = std::numeric_limits<double>::max()) const

Resets the state.

Parameters

  • [inout] state: State of the stepper

  • [in] boundParams: Parameters in bound parametrisation

  • [in] freeParams: Parameters in free parametrisation

  • [in] cov: Covariance matrix

  • [in] navDir: Navigation direction

  • [in] stepSize: Step size

void setStepSize(State &state, double stepSize, ConstrainedStep::Type stype = ConstrainedStep::actor) const

Set Step size - explicitely with a double.

Parameters

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

  • stepSize: [in] The step size value

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

template<typename propagator_state_t>
Result<double> step(propagator_state_t &state) const

Perform the actual step on the state.

Parameters

  • state: is the provided stepper state (caller keeps thread locality)

double time(const State &state) const

Time access.

void transportCovarianceToBound(State &state, const Surface &surface) const

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

Parameters

  • [inout] state: State of the stepper

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

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.

Return

the full transport jacobian

Parameters

  • [inout] state: State of the stepper

void update(State &state, const FreeVector &parameters, const Covariance &covariance) const

The state update method.

Parameters

  • [inout] state: The stepper state for

  • [in] pars: The new track parameters at start

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

Method to update momentum, direction and p.

Parameters

  • uposition: the updated position

  • udirection: the updated direction

  • p: the updated momentum value

template<typename object_intersection_t>
void updateStepSize(State &state, const object_intersection_t &oIntersection, bool release = true) const

Update step size.

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

Parameters

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

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

  • release: [in] boolean to trigger step size release

Intersection3D::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck, LoggerWrapper logger = getDummyLogger()) const

Update surface status.

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

Parameters

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

  • surface: [in] The surface provided

  • bcheck: [in] The boundary check for this status update

struct State

Nested State struct for the local caching.

Public Functions

State() = delete

Default constructor - deleted.

template<typename Parameters>
State(const GeometryContext &gctx, MagneticFieldProvider::Cache fieldCacheIn, const Parameters &pars, NavigationDirection ndir = forward, double ssize = std::numeric_limits<double>::max(), double stolerance = s_onSurfaceTolerance)

Constructor.

Type of TrackParameters

Parameters

  • [in] gctx: The geometry contex tof this call

  • [in] mctx: The magnetic field context of this call

  • [in] pars: Input parameters

  • [in] ndir: The navigation direction w.r.t. parameters

  • [in] ssize: the steps size limitation

  • [in] stolerance: is the stepping tolerance

Public Members

Covariance cov = Covariance::Zero()
const Covariance *covariance
bool covTransport = false
bool debug = false

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

size_t debugMsgWidth = 50
size_t debugPfxWidth = 30

buffer & formatting for consistent output

std::string debugString = ""
Vector3 field
MagneticFieldProvider::Cache fieldCache

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

See step() code for details.

std::reference_wrapper<const GeometryContext> geoContext

Cache the geometry context.

double jacobian[eBoundSize * eBoundSize]
double maxPathLength
bool mcondition
NavigationDirection navDir
bool needgradient
bool newfield
double parameters[eBoundSize] = {0., 0., 0., 0., 0., 0.}

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

double pathAccumulated = 0.
double previousStepSize = 0.
std::array<double, 60> pVector
bool state_ready = false
double step
ConstrainedStep stepSize = std::numeric_limits<double>::max()
double tolerance = s_onSurfaceTolerance

The tolerance for the stepping.

bool useJacobian