#1035 Adjusted the statistics calculators a bit.

ApplicationCode/ReservoirDataModel/RigEclipseNativeStatCalc.h

@@ -21,33 +21,26 @@
 
 #include "RigStatisticsCalculator.h"
 
-#include "cvfBase.h"
-#include "cvfObject.h"
-#include "cvfCollection.h"
-
 class RigHistogramCalculator;
 class RigCaseCellResultsData;
 
 //==================================================================================================
 /// 
 //==================================================================================================
+
 class RigEclipseNativeStatCalc : public RigStatisticsCalculator
 {
 public:
     RigEclipseNativeStatCalc(RigCaseCellResultsData* cellResultsData, size_t scalarResultIndex);
 
-    virtual void minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
+    virtual void    minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
-    virtual void posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
+    virtual void    posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
-
+    virtual void    valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
-    virtual void valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
+    virtual void    addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
-
-    virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
-
     virtual void    uniqueValues(size_t timeStepIndex, std::set<int>& values);
-
     virtual size_t  timeStepCount();
 
 private:
     RigCaseCellResultsData* m_resultsData;
-    size_t m_scalarResultIndex;
+    size_t                  m_scalarResultIndex;
 };

ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.cpp

@@ -262,7 +262,17 @@ const std::vector<int>& RigStatisticsDataCache::uniqueCellScalarValues()
 {
     computeUniqueValuesIfNeeded();
 
-    return m_uniqueValues;
+    return m_statsAllTimesteps.m_uniqueValues;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<int>& RigStatisticsDataCache::uniqueCellScalarValues(size_t timeStepIndex)
+{
+    computeUniqueValuesIfNeeded(timeStepIndex);
+
+    return m_statsPrTs[timeStepIndex].m_uniqueValues;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -334,15 +344,31 @@ void RigStatisticsDataCache::computeHistogramStatisticsIfNeeded(size_t timeStepI
 //--------------------------------------------------------------------------------------------------
 void RigStatisticsDataCache::computeUniqueValuesIfNeeded()
 {
-    if (m_uniqueValues.size() == 0)
+    if (m_statsAllTimesteps.m_uniqueValues.size() == 0)
     {
         std::set<int> setValues;
-        m_statisticsCalculator->uniqueValues(0, setValues);
+        m_statisticsCalculator->uniqueValues(0, setValues); // This is a Hack ! Only using first timestep. Ok for Static eclipse results but beware !
 
         for (auto val : setValues)
         {
-            m_uniqueValues.push_back(val);
+            m_statsAllTimesteps.m_uniqueValues.push_back(val);
         }
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigStatisticsDataCache::computeUniqueValuesIfNeeded(size_t timeStepIndex)
+{
+    if ( m_statsPrTs[timeStepIndex].m_uniqueValues.size() == 0 )
+    {
+        std::set<int> setValues;
+        m_statisticsCalculator->uniqueValues(timeStepIndex, setValues);
+
+        for ( auto val : setValues )
+        {
+            m_statsPrTs[timeStepIndex].m_uniqueValues.push_back(val);
+        }
+    }
+}

ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.h

@@ -56,12 +56,14 @@ public:
     const std::vector<size_t>&              cellScalarValuesHistogram(size_t timeStepIndex);
 
     const std::vector<int>&                 uniqueCellScalarValues();
+    const std::vector<int>&                 uniqueCellScalarValues(size_t timeStepIndex);
 
 private:
     void                                    computeHistogramStatisticsIfNeeded();
     void                                    computeHistogramStatisticsIfNeeded(size_t timeStepIndex);
 
     void                                    computeUniqueValuesIfNeeded();
+    void                                    computeUniqueValuesIfNeeded(size_t timeStepIndex);
 
 private:
     struct StatisticsValues
@@ -100,11 +102,12 @@ private:
         bool                m_isValueSumCalculated;
 
         std::vector<size_t> m_histogram;
+        std::vector<int>    m_uniqueValues;
     };
 
     StatisticsValues                m_statsAllTimesteps;
     std::vector<StatisticsValues>   m_statsPrTs;
-    std::vector<int>                m_uniqueValues;
+    
 
     cvf::ref<RigStatisticsCalculator>       m_statisticsCalculator;
 };

ApplicationCode/ResultStatisticsCache/RigStatisticsMath.h

@@ -62,7 +62,24 @@ private:
 class MinMaxAccumulator
 {
 public:
-    MinMaxAccumulator(double initMin, double initMax): max(initMax), min(initMin) {}
+    MinMaxAccumulator(double initMin = -HUGE_VAL, double initMax = HUGE_VAL): max(initMax), min(initMin) {}
+    
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         if (value == HUGE_VAL) // TODO
@@ -89,7 +106,24 @@ public:
 class PosNegAccumulator
 {
 public:
-    PosNegAccumulator(double initPos, double initNeg): pos(initPos), neg(initNeg) {}
+    PosNegAccumulator(double initPos = HUGE_VAL, double initNeg = -HUGE_VAL): pos(initPos), neg(initNeg) {}
+
+    void addData(const std::vector<double>& values) 
+    {
+        for (double val : values)
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         if (value == HUGE_VAL)
@@ -116,7 +150,23 @@ public:
 class SumCountAccumulator
 {
 public:
-    SumCountAccumulator(double initSum, size_t initCount): valueSum(initSum), sampleCount(initCount) {}
+    SumCountAccumulator(double initSum = 0.0, size_t initCount = 0): valueSum(initSum), sampleCount(initCount) {}
+
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
 
     void addValue(double value)
     {
@@ -140,6 +190,22 @@ public:
     UniqueValueAccumulator()
     {}
 
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         uniqueValues.insert(static_cast<int>(value));