Template Class InteractionList

Nested Relationships

Nested Types

Class Documentation

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

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 tpyically describe effective results of a large number of small interactions such as multiple scattering or ionisation. Continous 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.

The physics processes are extendable by the user to accomodate 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.

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.

Public 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.

Return

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

Template Parameters

  • generator_t: must be a RandomNumberEngine

Parameters

  • [in] rng: is the random number generator

  • [in] particle: is the initial particle state

void disable(size_t process)

Disable a specific process identified by index.

template<typename process_t>
void disable()

Disable a specific process identified by type.

Note

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

template<size_t kProcess>
std::tuple_element_t<kProcess, Processes> &get()

Access a specific process identified by index.

template<typename process_t>
process_t &get()

Access a specific process identified by type.

Warning

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

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.

Return

Break condition, i.e. whether a process stoped the propagation

Template Parameters

  • generator_t: must be a RandomNumberEngine

Parameters

  • [in] rng: is the random number generator

  • [in] slab: is the passed material

  • [inout] particle: is the particle being updated

  • [out] generated: is the container of generated particles

template<typename generator_t>
bool runPointLike(generator_t &rng, size_t processIndex, Particle &particle, std::vector<Particle> &generated) const

Simulate the effects from a single point-like interaction.

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.
Return

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

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

  • [inout] particle: is the particle being updated

  • [out] generated: is the container of generated particles

struct Selection

Point-like interaction selection.

Public Members

Particle::Scalar l0Limit = std::numeric_limits<Particle::Scalar>::infinity()
size_t l0Process = SIZE_MAX
Particle::Scalar x0Limit = std::numeric_limits<Particle::Scalar>::infinity()
size_t x0Process = SIZE_MAX