File InteractionList.hpp¶
-
namespace ActsFatras
-
template<typename ...processes_t>
class InteractionList - #include <ActsFatras/Kernel/InteractionList.hpp>
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>
inline Selection 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
rng – [in] is the random number generator
particle – [in] 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.
-
inline void disable(size_t process)
Disable a specific process identified by index.
-
template<typename process_t>
inline 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>
inline std::tuple_element_t<kProcess, Processes> &get() Access a specific process identified by index.
-
template<typename process_t>
inline 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>
inline 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 Parameters
generator_t – must be a RandomNumberEngine
- Parameters
rng – [in] is the random number generator
slab – [in] is the passed material
particle – [inout] is the particle being updated
generated – [out] is the container of generated particles
- Returns
Break condition, i.e. whether a process stoped the propagation
-
template<typename generator_t>
inline 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.- Template Parameters
generator_t – must be a RandomNumberEngine
- Parameters
rng – [in] is the random number generator
processIndex – [in] is the index of the process to be executed
particle – [inout] is the particle being updated
generated – [out] is the container of generated particles
- Returns
Break condition, i.e. whether a process killed the particle
Private Types
-
using Mask = std::bitset<sizeof...(processes_t)>¶
-
using Processes = std::tuple<processes_t...>¶
Private Functions
-
template<typename generator_t, std::size_t kI0, std::size_t... kIs>
inline void armPointLikeImpl(generator_t &rng, const Particle &particle, Selection &selection, std::index_sequence<kI0, kIs...>) const¶
-
template<typename generator_t>
inline void armPointLikeImpl(generator_t&, const Particle&, Selection&, std::index_sequence<>) const¶
-
template<typename generator_t, std::size_t kI0, std::size_t... kIs>
inline bool runContinuousImpl(generator_t &rng, const Acts::MaterialSlab &slab, Particle &particle, std::vector<Particle> &generated, std::index_sequence<kI0, kIs...>) const¶
-
template<typename generator_t>
inline bool runContinuousImpl(generator_t&, const Acts::MaterialSlab&, Particle&, std::vector<Particle>&, std::index_sequence<>) const¶
-
template<typename generator_t, size_t kI0, size_t... kIs>
inline bool runPointLikeImpl(generator_t &rng, size_t processIndex, Particle &particle, std::vector<Particle> &generated, std::index_sequence<kI0, kIs...>) const¶
-
template<typename generator_t>
inline bool runPointLikeImpl(generator_t&, size_t, Particle&, std::vector<Particle>&, std::index_sequence<>) const¶
-
struct Selection
- #include <ActsFatras/Kernel/InteractionList.hpp>
Point-like interaction selection.
-
template<typename generator_t>
-
template<typename ...processes_t>