Stepper based on a single-component stepper, but can handle Multi-Component Tracks (e.g., for the GSF). More...

#include <Acts/Propagator/MultiStepperLoop.hpp>

Inheritance diagram for Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >:

Classes
struct	Config
	Configuration for the multi-stepper loop. More...
struct	Options
struct	State
	State container for multi-component stepping. More...

Public Types
using	BoundParameters = MultiComponentBoundTrackParameters
	Type alias for bound track parameters.
using	ComponentProxy
	A proxy struct which allows access to a single component of the multi-component state.
using	ConstComponentProxy
	A proxy struct which allows access to a single component of the multi-component state.
using	Covariance = BoundMatrix
	Type alias for covariance matrix.
using	Jacobian = BoundMatrix
	Type alias for jacobian matrix.
using	Reducer = component_reducer_t
	The reducer type.
using	SingleConfig = typename SingleStepper::Config
	Typedef to the Config of the single component Stepper.
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 = single_stepper_t
	Typedef to the Single-Component Eigen Stepper.

Public Member Functions
	MultiStepperLoop (const Config &config, std::unique_ptr< const Logger > logger=getDefaultLogger("MultiStepperLoop", Logging::INFO))
	Constructor from a configuration and optionally provided Logger.
	MultiStepperLoop (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 TODO this requires that every stepper can be constructed like this...
double	absoluteMomentum (const State &state) const
	Absolute momentum accessor.
ComponentProxy	addComponent (State &state, const BoundTrackParameters &pars, double weight) const
	Add a component to the Multistepper.
Result< BoundParameters >	boundParameters (const State &state, const Surface &surface) const
	Get the bound parameters at the current position.
double	charge (const State &state) const
	Charge access.
void	clearComponents (State &state) const
	Reset the number of components.
auto	componentIterable (State &state) const
	Creates an iterable which can be plugged into a range-based for-loop to iterate over components.
auto	constComponentIterable (const State &state) const
	Creates an constant iterable which can be plugged into a range-based for-loop to iterate over components.
Result< Vector3 >	curvature (State &state) const
	Current global geometric curvature d(direction)/ds in inverse length.
BoundParameters	curvilinearParameters (const State &state) const
	Get the curvilinear parameters at the current position.
Vector3	direction (const State &state) const
	Momentum direction accessor.
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.
double	getStepSize (const State &state, ConstrainedStep::Type stype) const
	Get the step size.
bool	hasCovariance (const State &state) const
	Check if the state carries a covariance.
void	initialize (State &state, const BoundParameters &par) const
	Initialize the stepper state from multi-component bound track parameters.
State	makeState (const Options &options) const
	Create a state object for multi-stepping.
Vector3	momentum (const State &state) const
	Momentum accessor.
std::size_t	numberComponents (const State &state) const
	Get the number of components.
std::string	outputStepSize (const State &state) const
	Output the Step Size of all components into one std::string.
ParticleHypothesis	particleHypothesis (const State &state) const
	Particle hypothesis.
double	pathLength (const State &state) const
	Get the path length.
Vector3	position (const State &state) const
	Global particle position accessor.
bool	prepareCurvilinearState (State &state) const
	If necessary fill additional members needed for transportToCurvilinear.
double	qOverP (const State &state) const
	QoP access.
void	releaseStepSize (State &state, ConstrainedStep::Type stype) const
	Release the step-size for all components.
void	removeMissedComponents (State &state) const
	Remove missed components from the component state.
void	reweightComponents (State &state) const
	Reweight the components.
const SingleStepper &	singleStepper () const
	Get the single stepper instance.
const StepperStatistics &	statistics (const State &state) const
	Get the stepper statistics.
Result< double >	step (State &state, Direction propDir, const IVolumeMaterial *material) const
	Perform a Runge-Kutta track parameter propagation step.
double	time (const State &state) const
	Time access.
Result< Jacobian >	transportToBound (State &state, const Surface &surface, const FreeToBoundCorrection &freeToBoundCorrection=FreeToBoundCorrection(false)) const
	Put each component on a surface and transport its covariance there.
Jacobian	transportToCurvilinear (State &state) const
	Transport the covariance of each component to its curvilinear frame.
template<typename object_intersection_t>
void	updateStepSize (State &state, const object_intersection_t &oIntersection, Direction direction, ConstrainedStep::Type stype) const
	Update step size.
void	updateStepSize (State &state, double stepSize, ConstrainedStep::Type stype) const
	Update step size - explicitly with a double.
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.
Result< IntersectionStatus >	updateSurfaceStatusWithCurvature (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.

Static Public Attributes
static constexpr int	maxComponents = std::numeric_limits<int>::max()
	How many components can this stepper manage?

Detailed Description

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>
class Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >

Stepper based on a single-component stepper, but can handle Multi-Component Tracks (e.g., for the GSF).

Internally, this only manages a vector of states of the single stepper. 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

sstepper_t The single-component stepper type to use

component_reducer_t How to map the multi-component state to a single component

Member Typedef Documentation

◆ ComponentProxy

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::ComponentProxy

Initial value:

detail::LoopComponentProxy<typename State::Component, MultiStepperLoop>

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

◆ ConstComponentProxy

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::ConstComponentProxy

Initial value:

 
      detail::LoopComponentProxyBase<const typename State::Component,
                                     MultiStepperLoop>

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

Constructor & Destructor Documentation

◆ MultiStepperLoop() [1/2]

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::MultiStepperLoop	(	std::shared_ptr< const MagneticFieldProvider >	bField,
		std::unique_ptr< const Logger >	logger = getDefaultLogger("GSF", Logging::INFO) )

explicit

Constructor from a magnetic field and a optionally provided Logger TODO this requires that every stepper can be constructed like this...

Parameters

bField	Magnetic field provider to use for propagation
logger	Logger instance for debugging output

◆ MultiStepperLoop() [2/2]

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::MultiStepperLoop	(	const Config &	config,
		std::unique_ptr< const Logger >	logger = getDefaultLogger("MultiStepperLoop< single_stepper_t, component_reducer_t >", Logging::INFO) )

explicit

Constructor from a configuration and optionally provided Logger.

Parameters

config	Configuration object containing stepper settings
logger	Logger instance for debugging output

Member Function Documentation

◆ absoluteMomentum()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::absoluteMomentum ( const State & state ) const

Absolute momentum accessor.

Parameters

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

Returns: Absolute momentum magnitude from the reduced component state

◆ addComponent()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

ComponentProxy Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::addComponent	(	State &	state,
		const BoundTrackParameters &	pars,
		double	weight ) const

Add a component to the Multistepper.

Parameters

[in,out]	state	The stepping state (thread-local cache)
[in]	pars	Parameters of the component to add
[in]	weight	Weight of the component to add

Note: : It is not ensured that the weights are normalized afterwards; The component is initialized through the single stepper, so its jacobians are set whenever pars carries a covariance.; The returned component-proxy is only garantueed to be valid until the component number is again modified

Returns: ComponentProxy for the newly added component or error

◆ boundParameters()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< BoundParameters > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::boundParameters	(	const State &	state,
		const Surface &	surface ) const

Get the bound parameters at the current position.

The mixture combines the bound parameters of the components. Components that cannot be expressed on surface are ignored unless all fail.

Note: It does not check if the components are on surface. Use transportToBound to put them there.

Parameters

[in]	state	The stepping state (thread-local cache)
[in]	surface	The surface of the parameters

Returns: The bound mixture, or a failure if no component can be expressed on surface

◆ charge()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::charge ( const State & state ) const

Charge access.

Parameters

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

Returns: Electric charge value from the reduced component state

◆ clearComponents()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::clearComponents ( State & state ) const

Reset the number of components.

Parameters

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

◆ componentIterable()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

auto Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::componentIterable ( State & state ) const

Creates an iterable which can be plugged into a range-based for-loop to iterate over components.

Parameters

state Multi-component stepper state to iterate over

Note: Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference

Returns: Iterable range object that can be used in range-based for-loops

◆ constComponentIterable()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

auto Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::constComponentIterable ( const State & state ) const

Creates an constant iterable which can be plugged into a range-based for-loop to iterate over components.

Parameters

state Multi-component stepper state to iterate over (const)

Note: Use a for-loop with by-value semantics, since the Iterable returns a proxy internally holding a reference

Returns: Const iterable range object for read-only iteration over components

◆ curvature()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< Vector3 > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::curvature ( State & state ) const

Current global geometric curvature d(direction)/ds in inverse length.

Unchanged under propagation reversal; reflects current momentum and field. Uses the reduced position, direction and q/p, matching the other accessors.

Parameters

state Stepping state; the field cache may be updated

Returns: Curvature vector, or a field lookup error

◆ curvilinearParameters()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

BoundParameters Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::curvilinearParameters ( const State & state ) const

Get the curvilinear parameters at the current position.

Note: This is done as a simple average over the free representation and covariance of the components.

Parameters

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

Returns: The curvilinear mixture

◆ direction()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Vector3 Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::direction ( const State & state ) const

Momentum direction accessor.

Parameters

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

Returns: Normalized momentum direction vector from the reduced component state

◆ getField()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< Vector3 > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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

[in,out]	state	is the propagation state associated with the track the magnetic field cell is used (and potentially updated)
[in]	pos	is the field position

Note: This uses the cache of the first component stored in the state

Returns: Magnetic field vector at the given position or error

◆ getStepSize()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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

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.

Returns: Smallest step size among all components for the requested type

◆ hasCovariance()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

bool Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::hasCovariance ( const State & state ) const

Check if the state carries a covariance.

Parameters

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

Returns: True if the covariance is transported

◆ initialize()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::initialize	(	State &	state,
		const BoundParameters &	par ) const

Initialize the stepper state from multi-component bound track parameters.

Parameters

state	The stepper state to initialize
par	The multi-component bound track parameters

◆ makeState()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

State Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::makeState ( const Options & options ) const

Create a state object for multi-stepping.

Parameters

options The propagation options

Returns: Initialized state object for multi-stepper

◆ momentum()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Vector3 Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::momentum ( const State & state ) const

Momentum accessor.

Parameters

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

Returns: Momentum vector from the reduced component state

◆ numberComponents()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

std::size_t Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::numberComponents ( const State & state ) const

Get the number of components.

Parameters

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

Returns: Number of components in the multi-component state

◆ outputStepSize()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

std::string Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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)

Returns: String representation of all component step sizes concatenated

◆ particleHypothesis()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

ParticleHypothesis Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::particleHypothesis ( const State & state ) const

Particle hypothesis.

Parameters

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

Returns: Particle hypothesis used for this multi-component state

◆ pathLength()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::pathLength ( const State & state ) const

Get the path length.

Parameters

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

Returns: The weighted path length of the components

◆ position()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Vector3 Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::position ( const State & state ) const

Global particle position accessor.

Parameters

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

Returns: Global position vector from the reduced component state

◆ prepareCurvilinearState()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

bool Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::prepareCurvilinearState ( State & state ) const

If necessary fill additional members needed for transportToCurvilinear.

Parameters

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

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

◆ qOverP()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::qOverP ( const State & state ) const

QoP access.

Parameters

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

Returns: Charge over momentum (q/p) value from the reduced component state

◆ releaseStepSize()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::releaseStepSize	(	State &	state,
		ConstrainedStep::Type	stype ) const

Release the step-size for all components.

Parameters

	state	[in,out] The stepping state (thread-local cache)
[in]	stype	The step size type to be released

◆ removeMissedComponents()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::removeMissedComponents ( State & state ) const

Remove missed components from the component state.

Parameters

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

◆ reweightComponents()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::reweightComponents ( State & state ) const

Reweight the components.

Parameters

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

◆ singleStepper()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

const SingleStepper & Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::singleStepper ( ) const

Get the single stepper instance.

Returns: Reference to the single stepper instance used internally

◆ statistics()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

const StepperStatistics & Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::statistics ( const State & state ) const

Get the stepper statistics.

Parameters

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

Returns: The statistics since the last initialization

◆ step()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< double > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::step	(	State &	state,
		Direction	propDir,
		const IVolumeMaterial *	material ) const

Perform a Runge-Kutta track parameter propagation step.

Parameters

[in,out]	state	The state of the stepper
	propDir	is the direction of propagation
	material	is the material properties

Returns: the result of the 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.

◆ time()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

double Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::time ( const State & state ) const

Time access.

Parameters

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

Returns: Time coordinate from the reduced component state

◆ transportToBound()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< Jacobian > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::transportToBound	(	State &	state,
		const Surface &	surface,
		const FreeToBoundCorrection &	freeToBoundCorrection = FreeToBoundCorrection(false) ) const

Put each component on a surface and transport its covariance there.

The components are intersected with surface first, because a propagation can end when only the mean of the components reached it. Components that cannot be expressed on surface are ignored unless all fail.

Parameters

[in,out]	state	State of the stepper
[in]	surface	The surface to transport the components to
[in]	freeToBoundCorrection	Flag steering non-linear correction during global to local correction

Returns: The jacobian of the component the reducer selects, which also provides the position and direction of the state, or a failure if this component cannot be expressed on surface

◆ transportToCurvilinear()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Jacobian Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::transportToCurvilinear ( State & state ) const

Transport the covariance of each component to its curvilinear frame.

Parameters

[in,out] state State of the stepper

Returns: The jacobian of the component the reducer selects, which also provides the position and direction of the state

◆ updateStepSize() [1/2]

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

template<typename object_intersection_t>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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

◆ updateStepSize() [2/2]

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

void Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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

◆ updateSurfaceStatus()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

IntersectionStatus Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::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

[in,out]	state	The stepping state (thread-local cache)
[in]	surface	The surface provided
[in]	index	The surface intersection index
[in]	navDir	The navigation direction
[in]	boundaryTolerance	The boundary check for this status update
[in]	surfaceTolerance	Surface tolerance used for intersection
[in]	stype	The step size type to be set
[in]	logger	A `Logger` instance

Returns: IntersectionStatus indicating the overall status of all components relative to the surface

◆ updateSurfaceStatusWithCurvature()

template<Concepts::SingleStepper single_stepper_t, typename component_reducer_t = MaxWeightReducerLoop>

Result< IntersectionStatus > Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::updateSurfaceStatusWithCurvature	(	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

[in,out]	state	The stepping state (thread-local cache)
[in]	surface	The surface provided
[in]	index	The surface intersection index
[in]	navDir	The navigation direction
[in]	boundaryTolerance	The boundary check for this status update
[in]	surfaceTolerance	Surface tolerance used for intersection
[in]	stype	The step size type to be set
[in]	logger	A `Logger` instance

Returns: IntersectionStatus indicating the overall status of all components relative to the surface Query each component's curvature for the surface-status update.

sstepper_t	The single-component stepper type to use
component_reducer_t	How to map the multi-component state to a single component

Classes

Public Types

Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ ComponentProxy

◆ ConstComponentProxy

Constructor & Destructor Documentation

◆ MultiStepperLoop() [1/2]

◆ MultiStepperLoop() [2/2]

Member Function Documentation

◆ absoluteMomentum()

◆ addComponent()

◆ boundParameters()

◆ charge()

◆ clearComponents()

◆ componentIterable()

◆ constComponentIterable()

◆ curvature()

◆ curvilinearParameters()

◆ direction()

◆ getField()

◆ getStepSize()

◆ hasCovariance()

◆ initialize()

◆ makeState()

◆ momentum()

◆ numberComponents()

◆ outputStepSize()

◆ particleHypothesis()

◆ pathLength()

◆ position()

◆ prepareCurvilinearState()

◆ qOverP()

◆ releaseStepSize()

◆ removeMissedComponents()

◆ reweightComponents()

◆ singleStepper()

◆ statistics()

◆ step()

◆ time()

◆ transportToBound()

◆ transportToCurvilinear()

◆ updateStepSize() [1/2]

◆ updateStepSize() [2/2]

◆ updateSurfaceStatus()

◆ updateSurfaceStatusWithCurvature()