Compile-time set of interaction processes for the simulation. More...

#include <ActsFatras/Kernel/InteractionList.hpp>

Inheritance diagram for ActsFatras::InteractionList< processes_t >:

Classes
struct	Selection
	Point-like interaction selection. More...

Public Member Functions
template<typename generator_t>
Selection	armPointLike (generator_t &rng, const Particle &particle) const
	Arm the point-like interactions by generating limits and select processes.
template<typename process_t>
void	disable ()
	Disable a specific process identified by type.
void	disable (std::size_t process)
	Disable a specific process identified by index.
template<typename process_t>
process_t &	get ()
	Access a specific process identified by type.
template<std::size_t kProcess>
std::tuple_element_t< kProcess, Processes > &	get ()
	Access a specific process identified by index.
template<typename generator_t>
bool	runContinuous (generator_t &rng, const Acts::MaterialSlab &slab, Particle &particle, std::vector< Particle > &generated) const
	Simulate the combined effects from all continuous interactions.
template<typename generator_t>
bool	runPointLike (generator_t &rng, std::size_t processIndex, Particle &particle, std::vector< Particle > &generated) const
	Simulate the effects from a single point-like interaction.

Detailed Description

template<typename... processes_t>
class ActsFatras::InteractionList< processes_t >

Compile-time set of interaction processes for the simulation.

Two different type of interaction processes are supported: continuous and point-like interactions.

Continuous processes scale with the passed material. They typically describe effective results of a large number of small interactions such as multiple scattering or ionisation. Continuous process types must provide a call operator with the following signature:

template <typename generator_t>
bool
operator()(
    generator_t& rng,
    const Acts::MaterialSlab& slab,
    Particle& particle,
    std::vector<Particle>& generatedParticles) const

If multiple continuous processes are defined, they are executed serially in the order in which they are given.

For point-like processes, the passed material only affects the probability with which they occur but not the interaction itself, e.g. photon conversion into electron pairs. They are simulated by first drawing a limit on the material paths and then executing the interaction with the shortest limit when the drawn amount of material has been passed. Point-like process types must provide the following two member functions:

// generate X0/L0 limits
template <typename generator_t>
std::pair<Scalar, Scalar>
generatePathLimits(
    generator& rng,
    const Particle& particle) const

// run the process simulation
template <typename generator_t>
bool
run(
    generator_t& rng,
    Particle& particle,
    std::vector<Particle>& generatedParticles) const

For both continuous and point-like interactions, the output particle is modified in-place (if needed) and the return value indicates a break condition in the simulation, i.e. the particle is dead (true) or alive (false) after the interaction.

Note: If an interaction destroys the incoming particle, the process simulation should indicate this via the break condition only and not by reducing the particle momentum to zero. The incoming particle should retain its initial kinematic state; the final kinematic state before destruction is typically of more interest to the user and this simplifies validation.

The physics processes are extendable by the user to accommodate their specific requirements. While the set of available physics processes must be configured at compile-time, within that set, processes can again be selectively disabled at run-time. By default all processes are applied.

Member Function Documentation

◆ armPointLike()

template<typename... processes_t>

template<typename generator_t>

Selection ActsFatras::InteractionList< processes_t >::armPointLike	(	generator_t &	rng,
		const Particle &	particle ) const

Arm the point-like interactions by generating limits and select processes.

Template Parameters

generator_t must be a RandomNumberEngine

Parameters

[in]	rng	is the random number generator
[in]	particle	is the initial particle state

Returns: X0/L0 limits for the particle and the process index that should be executed once the limit has been reached.

◆ disable() [1/2]

template<typename... processes_t>

template<typename process_t>

void ActsFatras::InteractionList< processes_t >::disable ( )

Disable a specific process identified by type.

Note: Disables only the first element, if multiple elements of the same type exist.

◆ disable() [2/2]

template<typename... processes_t>

void ActsFatras::InteractionList< processes_t >::disable ( std::size_t process )

Disable a specific process identified by index.

Parameters

process Index of the process to disable

◆ get() [1/2]

template<typename... processes_t>

template<typename process_t>

process_t & ActsFatras::InteractionList< processes_t >::get ( )

Access a specific process identified by type.

Warning: This function only works if all configured processes have different types.

Returns: Reference to the process of the specified type

◆ get() [2/2]

template<typename... processes_t>

template<std::size_t kProcess>

std::tuple_element_t< kProcess, Processes > & ActsFatras::InteractionList< processes_t >::get ( )

Access a specific process identified by index.

Returns: Reference to the process at the specified index

◆ runContinuous()

template<typename... processes_t>

template<typename generator_t>

bool ActsFatras::InteractionList< processes_t >::runContinuous	(	generator_t &	rng,
		const Acts::MaterialSlab &	slab,
		Particle &	particle,
		std::vector< Particle > &	generated ) const

Simulate the combined effects from all continuous interactions.

Template Parameters

generator_t must be a RandomNumberEngine

Parameters

[in]	rng	is the random number generator
[in]	slab	is the passed material
[in,out]	particle	is the particle being updated
[out]	generated	is the container of generated particles

Returns: Break condition, i.e. whether a process stopped the propagation

◆ runPointLike()

template<typename... processes_t>

template<typename generator_t>

bool ActsFatras::InteractionList< processes_t >::runPointLike	(	generator_t &	rng,
		std::size_t	processIndex,
		Particle &	particle,
		std::vector< Particle > &	generated ) const

Simulate the effects from a single point-like interaction.

Template Parameters

generator_t must be a RandomNumberEngine

Parameters

[in]	rng	is the random number generator
[in]	processIndex	is the index of the process to be executed
[in,out]	particle	is the particle being updated
[out]	generated	is the container of generated particles

Returns: Break condition, i.e. whether a process killed the particle

The process index is expected to originate from a previous armPointLike(...) call, but this is not enforced. How to select the correct process requires more information that is not available here.

Classes

Public Member Functions

Detailed Description

Member Function Documentation

◆ armPointLike()

◆ disable() [1/2]

◆ disable() [2/2]

◆ get() [1/2]

◆ get() [2/2]

◆ runContinuous()

◆ runPointLike()