Class StraightLineStepper

Nested Relationships

Class Documentation

class Acts::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<BoundParameters, Jacobian, double>
using Covariance = BoundSymMatrix
using CurvilinearState = std::tuple<CurvilinearParameters, Jacobian, double>
using Jacobian = BoundMatrix
using state_type = State

Always use the same propagation state type, independently of the initial track parameter type and of the target surface.

Public Functions

StraightLineStepper() = default

Constructor.

BoundState boundState(State &state, const Surface &surface) 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

Return

A bound state:

  • the parameters at the surface

  • the stepwise jacobian towards it (from last bound)

  • 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

double charge(const State &state) const

Charge access.

Parameters

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

void covarianceTransport(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

  • [inout] state: State of the stepper

void covarianceTransport(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 - 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

  • [inout] state: The stepper state

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

CurvilinearState curvilinearState(State &state) const

Create and return a curvilinear state at the current position.

This creates a curvilinear state.

Return

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)

Parameters

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

Vector3D direction(const State &state) const

Momentum direction accessor.

Parameters

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

Vector3D getField(State&, const Vector3D&) const

Get the field for the stepping, this gives back a zero field.

Parameters

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

  • [in] pos: is the field position

double momentum(const State &state) const

Momentum accessor.

Parameters

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

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: The stepping state (thread-local cache)

Vector3D position(const State &state) const

Global particle position accessor.

Parameters

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

void releaseStepSize(State &state) const

Release the Step size.

Parameters

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

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 a straight line propagation step.

Return

the step size taken

Parameters

  • [inout] state: is the propagation state associated with the track parameters that are being propagated. The state contains the desired step size, it can be negative during backwards track propagation, and since we’re using an adaptive algorithm, it can be modified by the stepper class during propagation.

double time(const State &state) const

Time access.

Parameters

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

void update(State &state, const BoundParameters &pars) const

Method to update a stepper state to the some parameters.

Parameters

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

  • [in] pars: Parameters that will be written into state

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

Method to update momentum, direction and p.

Parameters

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

  • [in] uposition: the updated position

  • [in] udirection: the updated direction

  • [in] up: the updated momentum value

  • [in] time: the updated time 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

Intersection::Status updateSurfaceStatus(State &state, const Surface &surface, const BoundaryCheck &bcheck) 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: [in,out] The stepping state (thread-local cache)

  • surface: [in] The surface provided

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

struct State

State for track parameter propagation.

Public Functions

State() = delete

Delete the default constructor.

template<typename parameters_t>
State(std::reference_wrapper<const GeometryContext> gctx, std::reference_wrapper<const MagneticFieldContext>, const parameters_t &par, NavigationDirection ndir = forward, double ssize = std::numeric_limits<double>::max(), double stolerance = s_onSurfaceTolerance)

Constructor from the initial track parameters.

Template Parameters

  • parameters_t: the Type of the track parameters

Parameters

  • [in] gctx: is the context object for the geometery

  • [in] mctx: is the context object for the magnetic field

  • [in] par: The track parameters at start

  • [in] ndir: is the navigation direction

  • [in] ssize: is the (absolute) maximum step size

  • [in] stolerance: is the stepping tolerance

Public Members

Covariance cov = Covariance::Zero()
bool covTransport = false

Boolean to indiciate if you need covariance transport.

FreeVector derivative = FreeVector::Zero()

The propagation derivative.

Vector3D dir = Vector3D(1., 0., 0.)

Momentum direction (normalized)

std::reference_wrapper<const GeometryContext> geoContext
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.

NavigationDirection navDir

Navigation direction, this is needed for searching.

double p = 0.

Momentum.

double pathAccumulated = 0.

accummulated path length state

Vector3D pos = Vector3D(0., 0., 0.)

Global particle position.

double previousStepSize = 0.
double q = 0.

Save the charge: neutral as default for SL stepper.

ConstrainedStep stepSize = std::numeric_limits<double>::max()

adaptive step size of the runge-kutta integration

double t = 0.

Propagated time.

double tolerance = s_onSurfaceTolerance

The tolerance for the stepping.