fixed template class stuff

added missing unit test

Processes/DevTools/Analytics/CMakeLists.txt

@@ -13,11 +13,11 @@ set (
   corsika/process/devtools
   )
 
-add_library (ProcessDevTools STATIC ${MODEL_SOURCES})
-CORSIKA_COPY_HEADERS_TO_NAMESPACE (ProcessDevTools ${MODEL_NAMESPACE} ${MODEL_HEADERS})
+add_library (DevTools_Analytic STATIC ${MODEL_SOURCES})
+CORSIKA_COPY_HEADERS_TO_NAMESPACE (DevTools_Analytic ${MODEL_NAMESPACE} ${MODEL_HEADERS})
 
 set_target_properties (
-  ProcessDevTools
+  DevTools_Analytic
   PROPERTIES
   VERSION ${PROJECT_VERSION}
   SOVERSION 1
@@ -25,32 +25,39 @@ set_target_properties (
 
 # target dependencies on other libraries (also the header onlys)
 target_link_libraries (
-  ProcessDevTools
-  CORSIKAsetup
+  DevTools_Analytic
+  CORSIKAprocesssequence
+  CORSIKAunits
+  CORSIKAthirdparty  
   )
 
 target_include_directories (
-  ProcessDevTools 
+  DevTools_Analytic 
   INTERFACE 
   $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
   $<INSTALL_INTERFACE:include/include>
   )
 
 install (
-  TARGETS ProcessDevTools
+  TARGETS DevTools_Analytic
   LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib
-  PUBLIC_HEADER DESTINATION include/${MODEL_NAMESPACE}
+  ARCHIVE DESTINATION lib 
   )
 
 
 # --------------------
 # code unit testing
-CORSIKA_ADD_TEST (testExecTime testExecTime.cc)
+CORSIKA_ADD_TEST (testExecTime
+ SOURCES
+ testExecTime.cc
+ ${MODEL_HEADERS}
+)
+
 target_link_libraries (
-  testExecTime  ProcessDevTools
-  CORSIKAsetup
+  testExecTime  
+  DevTools_Analytic  
   DevTools_Dummy
+  CORSIKAtesting
   CORSIKAthirdparty # for catch2
   )
 

Processes/DevTools/Analytics/ExecTime.cc

@@ -14,51 +14,90 @@
 namespace corsika::process {
   namespace devtools {
 
-    template <class T>
-    void ExecTime<T>::start() {
-      fStart = std::chrono::steady_clock::now();
-    }
+ 
 
-    template <class T>
-    void ExecTime<T>::stop() {
-      auto end = std::chrono::steady_clock::now();
-      std::chrono::microseconds timeDiv =
-          std::chrono::duration_cast<std::chrono::microseconds>(end - start);
-
-      fElapsedSum += timeDiv;
-      fN++;
-
-      if (fMax < timeDiv) fMax = timeDiv;
-
-      if (timeDiv < fMin) fMin = timeDiv;
-
-      auto delta = timeDiv - fMean;
-      fMean += delta / fN;
-
-      auto delta2 = timeDiv - fMean;
+  } // namespace devtools
+} // namespace corsika::process
 
-      fMean2 += delta * delta2;
-    }
+/*
+ template <typename T, bool>
+    class ExecTime_BoundaryCrossing {};
 
     template <typename T>
-    double ExecTime<T>::mean() {
-      return fMean;
-    }
+    class ExecTime_BoundaryCrossing<T, true> : protected T {
+    public:
+      template <
+          typename Particle, typename VTNType,
+          typename std::enable_if_t<
+              std::is_base_of<BoundaryCrossingProcess<typename T::_TDerived>, T>::value,
+              int> = 0>
+      EProcessReturn DoBoundaryCrossing(Particle& p, VTNType const& from,
+                                        VTNType const& to) {
+
+        return T::DoBoundaryCrossing(p, from, to);
+      }
+    };
+
+    template <typename T, bool>
+    class ExecTime_Continuous {};
 
     template <typename T>
-    double ExecTime<T>::var() {
-      return fMean2 / count;
-    }
+    class ExecTime_Continuous<T, true> : protected T {
+    public:
+      template <typename Particle, typename Track>
+      EProcessReturn DoContinuous(Particle& p, Track const& t) const {
+        return T::DoContinous(p, t);
+      }
+
+      template <typename Particle, typename Track>
+      units::si::LengthType MaxStepLength(Particle const& p, Track const& track) const {
+        return T::MaxStepLength(p, track);
+      }
+    };
+
+    template <typename T, bool>
+    class ExecTime_Decay {};
 
     template <typename T>
-    double ExecTime<T>::min() {
-      return fMin;
-    }
+    class ExecTime_Decay<T, true> : protected T {
+    public:
+      template <typename Particle>
+      EProcessReturn DoDecay(Particle& p) {
+        return T::DoDecay(p);
+      }
+
+      template <typename Particle>
+      corsika::units::si::TimeType GetLifetime(Particle& p) {
+        return T::GetLifetime(p);
+      }
+    };
+
+    template <typename T, bool>
+    class ExecTime_Interaction {};
 
     template <typename T>
-    double ExecTime<T>::max() {
-      return fMax;
-    }
+    class ExecTime_Interaction<T, true> : protected T {
+    public:
+      template <typename Particle>
+      EProcessReturn DoInteraction(Particle& p) {
+        return T::DoInteraction(p);
+      }
+
+      template <typename Particle>
+      corsika::units::si::GrammageType GetInteractionLength(Particle& p) {
+        return T::GetInteractionLength(p);
+      }
+    };
+
+    template <typename T, bool>
+    class ExecTime_Secondaries {};
 
-  } // namespace devtools
-} // namespace corsika::process
+    template <typename T>
+    class ExecTime_Secondaries<T, true> : protected T {
\ No newline at end of file
+    public:
+      template <typename Secondaries>
+      inline EProcessReturn DoSecondaries(Secondaries& sec) {
+        return T::DoSecondaries(sec);
+      }
+    };
+    */
\ No newline at end of file

Processes/DevTools/Analytics/ExecTime.h

@@ -21,117 +21,118 @@
 namespace corsika::process {
   namespace devtools {
 
-    template <typename T, bool>
-    class ExecTime_BoundaryCrossing {};
-
     template <typename T>
-    class ExecTime_BoundaryCrossing<T, true> : protected T {
+    class ExecTime : private T {
+    private:
+      std::chrono::high_resolution_clock::time_point fStart;
+      std::chrono::duration<double,std::micro> fElapsedSum;
+      double fMean;
+      double fMean2;
+      double fMin;
+      double fMax;
+      long long fN;
+
+    protected:
     public:
-      template <
-          typename Particle, typename VTNType,
-          typename std::enable_if_t<
-              std::is_base_of<BoundaryCrossingProcess<typename T::_TDerived>, T>::value,
-              int> = 0>
+      ExecTime() {
+        fMin = std::numeric_limits<long long>::max();
+        fMax = 0;
+        fMean = 0;
+        fMean2 = 0;
+        fN = 0;
+      }
+
+      void start() { fStart = std::chrono::high_resolution_clock::now(); }
+      void stop() {
+        auto end = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double,std::micro> timeDiv =
+            std::chrono::duration_cast< std::chrono::duration<double,std::micro> >(end - fStart);
+
+        fElapsedSum += timeDiv;
+        fN = fN + 1;
+
+        if (fMax < timeDiv.count()) fMax = timeDiv.count();
+
+        if (timeDiv.count() < fMin) fMin = timeDiv.count();
+
+        double delta = timeDiv.count() - fMean;
+        fMean += delta / static_cast<double>(fN);
+
+        double delta2 = timeDiv.count() - fMean;
+
+        fMean2 += delta * delta2;
+      }
+
+      double mean() const { return fMean; }
+      double min() const { return fMin; }
+      double max() const { return fMax; }
+      double var() const { return fMean2 / fN; }
+      double sumTime() const { return fElapsedSum.count(); }
+
+      template <typename Particle, typename VTNType>
       EProcessReturn DoBoundaryCrossing(Particle& p, VTNType const& from,
                                         VTNType const& to) {
-        return T::DoBoundaryCrossing(p, from, to);
+        this->start();
+        auto r = T::DoBoundaryCrossing(p, from, to);
+        this->stop();
+        return r;
       }
-    };
-
-    template <typename T, bool>
-    class ExecTime_Continuous {};
 
-    template <typename T>
-    class ExecTime_Continuous<T, true> : protected T {
-    public:
       template <typename Particle, typename Track>
       EProcessReturn DoContinuous(Particle& p, Track const& t) const {
-        return T::DoContinous(p, t);
+        this->start();
+        auto r = T::DoContinous(p, t);
+        this->stop();
+        return r;
       }
 
       template <typename Particle, typename Track>
       units::si::LengthType MaxStepLength(Particle const& p, Track const& track) const {
-        return T::MaxStepLength(p, track);
+        this->start();
+        auto r = T::MaxStepLength(p, track);
+        this->stop();
+        return r;
       }
-    };
 
-    template <typename T, bool>
-    class ExecTime_Decay {};
-
-    template <typename T>
-    class ExecTime_Decay<T, true> : protected T {
-    public:
       template <typename Particle>
       EProcessReturn DoDecay(Particle& p) {
-        return T::DoDecay(p);
+        this->start();
+        auto r = T::DoDecay(p);
+        this->stop();
+        return r;
       }
 
       template <typename Particle>
       corsika::units::si::TimeType GetLifetime(Particle& p) {
-        return T::GetLifetime(p);
+        this->start();
+        auto r = T::GetLifetime(p);
+        this->stop();
+        return r;
       }
-    };
-
-    template <typename T, bool>
-    class ExecTime_Interaction {};
 
-    template <typename T>
-    class ExecTime_Interaction<T, true> : protected T {
-    public:
       template <typename Particle>
       EProcessReturn DoInteraction(Particle& p) {
-        return T::DoInteraction(p);
+        this->start();
+        auto r = T::DoInteraction(p);
+        this->stop();
+        return r;
       }
 
       template <typename Particle>
       corsika::units::si::GrammageType GetInteractionLength(Particle& p) {
-        return T::GetInteractionLength(p);
+        this->start();
+        auto r = T::GetInteractionLength(p);
+        this->stop();
+        return r;
       }
-    };
 
-    template <typename T, bool>
-    class ExecTime_Secondaries {};
-
-    template <typename T>
-    class ExecTime_Secondaries<T, true> : protected T {
-    public:
       template <typename Secondaries>
       inline EProcessReturn DoSecondaries(Secondaries& sec) {
-        return T::DoSecondaries(sec);
+        this->start();
+        auto r = T::DoSecondaries(sec);
+        this->stop();
+        return r;
       }
-    };
-
-    template <typename T>
-    class ExecTime
-        : public ExecTime_BoundaryCrossing<
-              T,
-              std::is_base_of<BoundaryCrossingProcess<typename T::_TDerived>, T>::value>,
-          public ExecTime_Continuous<
-              T, std::is_base_of<ContinuousProcess<typename T::_TDerived>, T>::value>,
-          public ExecTime_Decay<
-              T, std::is_base_of<DecayProcess<typename T::_TDerived>, T>::value>,
-          public ExecTime_Interaction<
-              T, std::is_base_of<InteractionProcess<typename T::_TDerived>, T>::value>,
-          public ExecTime_Secondaries<
-              T, std::is_base_of<SecondariesProcess<typename T::_TDerived>, T>::value> {
-    private:
-      std::chrono::microseconds fStart;
-      std::chrono::microseconds fElapsedSum;
-      std::chrono::microseconds fMean;
-      std::chrono::microseconds fMean2;
-      std::chrono::microseconds fMin;
-      std::chrono::microseconds fMax;
-      long long fN;
-
-      void start();
-      void stop();
-
-    protected:
-    public:
-      double mean();
-      double min();
-      double max();
-      double var();
 
       /*
                   // Stack

Processes/DevTools/Analytics/testExecTime.cc

@@ -18,12 +18,14 @@
 #include <corsika/process/devtools/DummyInteractionProcess.h>
 #include <corsika/process/devtools/DummySecondariesProcess.h>
 
+#include <random>
+
 using namespace corsika::process;
 using namespace corsika::process::devtools;
 
 TEST_CASE("ContinuousProcess interface", "[proccesses][DevTools ExecTime]") {
 
-  ExecTime<DummyBoundaryCrossingProcess<100>> execTime;
+  ExecTime<DummyBoundaryCrossingProcess<50>> execTime;
   int tmp = 0;
 
   SECTION("BoundaryCrossing") {
@@ -31,6 +33,48 @@ TEST_CASE("ContinuousProcess interface", "[proccesses][DevTools ExecTime]") {
     REQUIRE(execTime.DoBoundaryCrossing(tmp, 0, 0) == EProcessReturn::eOk);
     auto end = std::chrono::steady_clock::now();
     REQUIRE(std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() ==
-            Approx(100).margin(1));
+            Approx(50).margin(1));
+
+    for (int i = 0; i < 100; i++) execTime.DoBoundaryCrossing(tmp, 0, 0);
+
+    REQUIRE(execTime.mean() == Approx(50 * 1000).margin(1 * 1000));
+
+    REQUIRE(execTime.sumTime() == Approx(50 * 100 * 1000).margin(100 * 1000));
+
+    REQUIRE(execTime.var() == Approx(0).margin(20000));
+  }
+
+  SECTION("TestMeanAlgo") {
+    std::default_random_engine generator;
+    std::normal_distribution<double> distribution(10000.0, 200.0);
+
+    double fStart;
+    double fElapsedSum;
+    double fMean;
+    double fMean2;
+    long long fMin;
+    long long fMax;
+    long long fN;
+
+    for (int i = 0; i < 1000000; i++) {
+      auto timeDiv = distribution(generator);
+
+      fElapsedSum += timeDiv;
+      fN = fN + 1;
+
+      if (fMax < timeDiv) fMax = timeDiv;
+
+      if (timeDiv < fMin) fMin = timeDiv;
+
+      double delta = timeDiv - fMean;
+      fMean += delta / static_cast<double>(fN);
+
+      double delta2 = timeDiv - fMean;
+
+      fMean2 += delta * delta2;
+    }
+
+    REQUIRE(fMean2 / fN == Approx(200*200).margin(200)); // Varianz
+    REQUIRE(fMean == Approx(10000).margin(10));
   }
 }