CORSIKA  @c8_version@
The framework to simulate particle cascades for astroparticle physics
corsika::StackProcess< TDerived > Class Template Reference

Process to act on the entire particle stack. More...

#include <StackProcess.hpp>

Inheritance diagram for corsika::StackProcess< TDerived >:

Public Member Functions

 StackProcess (const unsigned int nStep)
 
int getStep () const
 return the current Cascade step counter
 
bool checkStep ()
 check if current step is where StackProcess should be executed, this also increases the internal step counter implicitly
 

Static Public Attributes

static bool const is_stack_process = true
 
- Static Public Attributes inherited from corsika::BaseProcess< TDerived >
static bool const is_process_sequence = false
 
static bool const is_switch_process_sequence = false
 

Additional Inherited Members

- Public Types inherited from corsika::BaseProcess< TDerived >
using process_type = TDerived
 Base processor type for use in other template classes.
 
- Protected Member Functions inherited from corsika::BaseProcess< TDerived >
TDerived & getRef ()
 
const TDerived & getRef () const
 
- Protected Attributes inherited from corsika::BaseProcess< TDerived >
friend TDerived
 

Detailed Description

template<typename TDerived>
class corsika::StackProcess< TDerived >

Process to act on the entire particle stack.

Create a new StackProcess, e.g. for XYModel, via:

class XYModel : public StackProcess<XYModel> {};

and provide the necessary interface method:

template <typename TStack>
void XYModel::doStack(TStack&);

Where, of course, Stack is the valid class to access particles on the Stack. This methods does not need to be templated, they could use the types e.g. corsika::setup::Stack directly – but by the cost of loosing all flexibility otherwise provided.

A StackProcess has only one constructor StackProcess::StackProcess(unsigned int const nStep) where nStep ( \(n_{step}\)) is the number of steps of the cascade stepping after which the stack process should be run. Good values are on the order of 1000, which will not compromise run time in the end, but provide all the benefits of the StackProcess.

The number of steps during the cascade processing after which a StackProcess is going to be executed is determined from iStep_ and nStep_ using the modulo: \( !(iStep\_ \; \% \; nStep\_) \). And iStep_ is increased for each evaluation (step).

Definition at line 54 of file StackProcess.hpp.


The documentation for this class was generated from the following file: