make StackInspector a StackProcess, add tests, adapt examples

Documentation/Examples/cascade_example.cc

@@ -274,7 +274,7 @@ int main() {
 
   // setup processes, decays and interactions
   tracking_line::TrackingLine tracking;
-  stack_inspector::StackInspector<setup::Stack> stackInspect(true);
+  stack_inspector::StackInspector<setup::Stack> stackInspect(1, true);
 
   const std::vector<particles::Code> trackedHadrons = {
       particles::Code::PiPlus, particles::Code::PiMinus, particles::Code::KPlus,

Framework/Cascade/testCascade.cc

@@ -138,7 +138,7 @@ TEST_CASE("Cascade", "[Cascade]") {
   auto env = MakeDummyEnv();
   tracking_line::TrackingLine tracking;
 
-  stack_inspector::StackInspector<TestCascadeStack> stackInspect(true);
+  stack_inspector::StackInspector<TestCascadeStack> stackInspect(1, true);
   null_model::NullModel nullModel;
 
   const GrammageType X0 = 20_g / square(1_cm);

Framework/ProcessSequence/ProcessSequence.h

@@ -119,16 +119,29 @@ namespace corsika::process {
       return ret;
     }
 
+    bool CheckStep() {
+      bool ret = false;
+      if constexpr (std::is_base_of<StackProcess<T1type>, T1type>::value ||
+                    is_process_sequence<T1>::value) {
+        ret |= A.CheckStep();
+      }
+      if constexpr (std::is_base_of<StackProcess<T2type>, T2type>::value ||
+                    is_process_sequence<T2>::value) {
+        ret |= B.CheckStep();
+      }
+      return ret;
+    }
+
     template <typename TStack>
     EProcessReturn DoStack(TStack& vS) {
       EProcessReturn ret = EProcessReturn::eOk;
       if constexpr (std::is_base_of<StackProcess<T1type>, T1type>::value ||
                     is_process_sequence<T1>::value) {
-        ret |= A.DoStack(vS);
+        if (A.CheckStep()) { ret |= A.DoStack(vS); }
       }
       if constexpr (std::is_base_of<StackProcess<T2type>, T2type>::value ||
                     is_process_sequence<T2>::value) {
-        ret |= B.DoStack(vS);
+        if (B.CheckStep()) { ret |= B.DoStack(vS); }
       }
       return ret;
     }

Framework/ProcessSequence/StackProcess.h

@@ -28,7 +28,12 @@ namespace corsika::process {
    */
 
   template <typename derived>
-  struct StackProcess {
+  class StackProcess {
+
+  public:
+    StackProcess() = delete;
+    StackProcess(const unsigned int nStep)
+        : fNStep(nStep) {}
 
     derived& GetRef() { return static_cast<derived&>(*this); }
     const derived& GetRef() const { return static_cast<const derived&>(*this); }
@@ -37,6 +42,19 @@ namespace corsika::process {
     // -> enforce derived to implement DoStack...
     template <typename TStack>
     inline EProcessReturn DoStack(TStack&);
+
+    bool CheckStep() { return !((++fIStep) % fNStep); }
+
+  private:
+    /**
+       @name The number of "steps" during the cascade processing after
+       which this StackProcess is going to be executed. The logic is
+       "fIStep modulo fNStep"
+       @{
+     */
+    unsigned int fNStep = 0;
+    unsigned long int fIStep = 0;
+    //! @}
   };
 
   // overwrite the default trait class, to mark BaseProcess<T> as useful process

Framework/ProcessSequence/testProcessSequence.cc

@@ -174,6 +174,21 @@ public:
   }
 };
 
+class Stack1 : public StackProcess<Stack1> {
+  int fCount = 0;
+
+public:
+  Stack1(const int n)
+      : StackProcess(n) {}
+  template <typename TStack>
+  EProcessReturn DoStack(TStack&) {
+    fCount++;
+    return EProcessReturn::eOk;
+  }
+  int GetCount() const { return fCount; }
+};
+
+struct DummyStack {};
 struct DummyData {
   double p[nData] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 };
@@ -257,4 +272,24 @@ TEST_CASE("Process Sequence", "[Process Sequence]") {
     }
     cout << "done" << endl;
   }
+
+  SECTION("StackProcess") {
+
+    ContinuousProcess1 cp1(0);
+    ContinuousProcess2 cp2(3);
+    Process2 m2(1);
+    Process3 m3(2);
+    Stack1 s1(1);
+    Stack1 s2(2);
+
+    auto sequence = s1 << s2;
+
+    DummyStack stack;
+
+    const int nLoop = 20;
+    for (int i = 0; i < nLoop; ++i) { sequence.DoStack(stack); }
+
+    CHECK(s1.GetCount() == 20);
+    CHECK(s2.GetCount() == 10);
+  }
 }

Processes/StackInspector/StackInspector.cc

@@ -28,8 +28,9 @@ using namespace corsika::units::si;
 using namespace corsika::process::stack_inspector;
 
 template <typename Stack>
-StackInspector<Stack>::StackInspector(const bool aReport)
-    : fReport(aReport)
+StackInspector<Stack>::StackInspector(const int nStep, const bool aReport)
+    : StackProcess<StackInspector<Stack>>(nStep)
+    , fReport(aReport)
     , fCountStep(0) {}
 
 template <typename Stack>

Processes/StackInspector/StackInspector.h

@@ -26,7 +26,7 @@ namespace corsika::process {
       typedef typename Stack::ParticleType Particle;
 
     public:
-      StackInspector(const bool aReport);
+      StackInspector(const int nStep, const bool aReport);
       ~StackInspector();
 
       void Init();

Processes/StackInspector/testStackInspector.cc

@@ -50,7 +50,7 @@ TEST_CASE("StackInspector", "[processes]") {
 
   SECTION("interface") {
 
-    StackInspector<TestCascadeStack> model(true);
+    StackInspector<TestCascadeStack> model(1, true);
 
     model.Init();
     [[maybe_unused]] const process::EProcessReturn ret = model.DoStack(stack);