Template Class InteractionList¶
Defined in File InteractionList.hpp
Nested Relationships¶
Nested Types¶
Class Documentation¶
-
template<typename ...
processes_t
>
classActsFatras
::
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
>
SelectionarmPointLike
(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
>
voiddisable
()¶ 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
>
boolrunContinuous
(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
>
boolrunPointLike
(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.