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 >:

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

Classes
struct	Config
struct	Options
struct	State

Public Types
using	BoundState
	Define an own bound state.
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	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.
Result< ComponentProxy >	addComponent (State &state, const BoundTrackParameters &pars, double weight) const
	Add a component to the Multistepper.
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.
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.
BoundState	curvilinearState (State &state, bool transportCov=true) const
	Create and return a curvilinear state 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.
void	initialize (State &state, const MultiComponentBoundTrackParameters &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.
Vector3	position (const State &state) const
	Global particle position accessor.
bool	prepareCurvilinearState (State &state) const
	If necessary fill additional members needed for curvilinearState.
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.
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.
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.
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.
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.

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

◆ BoundState

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

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

Initial value:

std::tuple<MultiComponentBoundTrackParameters, Jacobian, double>

Define an own bound state.

◆ 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

◆ Reducer

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

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::Reducer = component_reducer_t

The reducer type.

◆ SingleConfig

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

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::SingleConfig = typename SingleStepper::Config

Typedef to the Config of the single component Stepper.

◆ SingleOptions

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

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::SingleOptions = typename SingleStepper::Options

Typedef to the Single-Component Stepper Options.

◆ SingleState

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

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::SingleState = typename SingleStepper::State

Typedef to the State of the single component Stepper.

◆ SingleStepper

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

using Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::SingleStepper = single_stepper_t

Typedef to the Single-Component Eigen Stepper.

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>

Result< 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; 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.; 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

◆ boundState()

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

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

[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
[in]	freeToBoundCorrection	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)

◆ 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

◆ curvilinearState()

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

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

[in]	state	State that will be presented as `CurvilinearState`
[in]	transportCov	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)

◆ 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

◆ 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 MultiComponentBoundTrackParameters &	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

◆ 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 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

[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)

◆ 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

◆ transportCovarianceToBound()

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

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

Template Parameters

surface_t the Surface type

Parameters

[in,out]	state	State of the stepper
[in]	surface	is the surface to which the covariance is forwarded
[in]	freeToBoundCorrection	Flag steering non-linear correction during global to local correction to

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

◆ transportCovarianceToCurvilinear()

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

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

[in,out] state State of the stepper

◆ 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

Member Data Documentation

◆ maxComponents

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

int Acts::MultiStepperLoop< single_stepper_t, component_reducer_t >::maxComponents = std::numeric_limits<int>::max()

staticconstexpr

How many components can this stepper manage?

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

◆ BoundState

◆ ComponentProxy

◆ ConstComponentProxy

◆ Reducer

◆ SingleConfig

◆ SingleOptions

◆ SingleState

◆ SingleStepper

Constructor & Destructor Documentation

◆ MultiStepperLoop() [1/2]

◆ MultiStepperLoop() [2/2]

Member Function Documentation

◆ absoluteMomentum()

◆ addComponent()

◆ boundState()

◆ charge()

◆ clearComponents()

◆ componentIterable()

◆ constComponentIterable()

◆ curvilinearState()

◆ direction()

◆ getField()

◆ getStepSize()

◆ initialize()

◆ makeState()

◆ momentum()

◆ numberComponents()

◆ outputStepSize()

◆ particleHypothesis()

◆ position()

◆ prepareCurvilinearState()

◆ qOverP()

◆ releaseStepSize()

◆ removeMissedComponents()

◆ reweightComponents()

◆ step()

◆ time()

◆ transportCovarianceToBound()

◆ transportCovarianceToCurvilinear()

◆ updateStepSize() [1/2]

◆ updateStepSize() [2/2]

◆ updateSurfaceStatus()

Member Data Documentation

◆ maxComponents