Move RigCurveDataTools and RigTimeHistoryCurveMerger to Application/Tools plus rename

ApplicationCode/Application/Tools/CMakeLists_files.cmake

@@ -24,6 +24,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RiaTextFileCompare.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaRegressionTestRunner.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaExtractionTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaFilePathTools.h
+${CMAKE_CURRENT_LIST_DIR}/RiaTimeHistoryCurveMerger.h
+${CMAKE_CURRENT_LIST_DIR}/RiaCurveDataTools.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -51,6 +53,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RiaTextFileCompare.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaRegressionTestRunner.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaExtractionTools.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaFilePathTools.cpp
+${CMAKE_CURRENT_LIST_DIR}/RiaTimeHistoryCurveMerger.cpp
+${CMAKE_CURRENT_LIST_DIR}/RiaCurveDataTools.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationCode/Application/Tools/RiaCurveDataTools.cpp

@@ -0,0 +1,107 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2015-     Statoil ASA
+//  Copyright (C) 2015-     Ceetron Solutions AS
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RiaCurveDataTools.h"
+
+
+#include <cmath> // Needed for HUGE_VAL on Linux 
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RiaCurveDataTools::CurveIntervals RiaCurveDataTools::calculateIntervalsOfValidValues(const std::vector<double>& values,
+                                                                                     bool includePositiveValuesOnly)
+{
+    CurveIntervals intervals;
+
+    int startIdx = -1;
+    size_t vIdx = 0;
+
+    size_t valueCount = values.size();
+    while (vIdx < valueCount)
+    {
+        bool isValid = RiaCurveDataTools::isValidValue(values[vIdx], includePositiveValuesOnly);
+
+        if (!isValid)
+        {
+            if (startIdx >= 0)
+            {
+                intervals.push_back(std::make_pair(startIdx, vIdx - 1));
+                startIdx = -1;
+            }
+        }
+        else if (startIdx < 0)
+        {
+            startIdx = (int)vIdx;
+        }
+
+        vIdx++;
+    }
+
+    if (startIdx >= 0 && startIdx < ((int)valueCount))
+    {
+        intervals.push_back(std::make_pair(startIdx, valueCount - 1));
+    }
+
+    return intervals;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<std::pair<size_t, size_t>> RiaCurveDataTools::computePolyLineStartStopIndices(const CurveIntervals& intervals)
+{
+    std::vector<std::pair<size_t, size_t>> lineStartAndStopIndices;
+
+    const size_t intervalCount = intervals.size();
+    if (intervalCount < 1) return lineStartAndStopIndices;
+
+    size_t index = 0;
+    for (size_t intIdx = 0; intIdx < intervalCount; intIdx++)
+    {
+        size_t intervalSize = intervals[intIdx].second - intervals[intIdx].first + 1;
+        lineStartAndStopIndices.push_back(std::make_pair(index, index + intervalSize - 1));
+
+        index += intervalSize;
+    }
+
+    return lineStartAndStopIndices;
+}
+
+
+//-------------------------------------------------------------------------------------------------- 
+///  
+//-------------------------------------------------------------------------------------------------- 
+bool RiaCurveDataTools::isValidValue(double value, bool allowPositiveValuesOnly)
+{
+    if (value == HUGE_VAL || value == -HUGE_VAL || value != value)
+    {
+        return false;
+    }
+
+    if (allowPositiveValuesOnly && value <= 0)
+    {
+        return false;
+    }
+
+    return true;
+}
+

ApplicationCode/Application/Tools/RiaCurveDataTools.h

@@ -0,0 +1,65 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2015-     Statoil ASA
+//  Copyright (C) 2015-     Ceetron Solutions AS
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cvfAssert.h"
+
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include <set>
+
+class QDateTime;
+
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RiaCurveDataTools
+{
+public:
+    typedef std::vector<std::pair<size_t, size_t>> CurveIntervals;
+
+public:
+    static CurveIntervals calculateIntervalsOfValidValues(const std::vector<double>& values,
+                                                          bool includePositiveValuesOnly);
+
+    template <typename T>
+    static void getValuesByIntervals(const std::vector<T>& values,
+                                     const CurveIntervals& intervals,
+                                     std::vector<T>* filteredValues)
+    {
+        CVF_ASSERT(filteredValues);
+
+        for (size_t intIdx = 0; intIdx < intervals.size(); intIdx++)
+        {
+            for (size_t vIdx = intervals[intIdx].first; vIdx <= intervals[intIdx].second; vIdx++)
+            {
+                filteredValues->push_back(values[vIdx]);
+            }
+        }
+    }
+
+    static std::vector<std::pair<size_t, size_t>> computePolyLineStartStopIndices(const CurveIntervals& intervals);
+
+public:
+    static bool isValidValue(double value, bool allowPositiveValuesOnly);
+};
+

ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.cpp

@@ -0,0 +1,223 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2017     Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RiaTimeHistoryCurveMerger.h"
+
+
+#include <cmath> // Needed for HUGE_VAL on Linux 
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RiaTimeHistoryCurveMerger::RiaTimeHistoryCurveMerger()
+{
+
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiaTimeHistoryCurveMerger::addCurveData(const std::vector<double>& values, const std::vector<time_t>& timeSteps)
+{
+    CVF_ASSERT(values.size() == timeSteps.size());
+
+    m_originalValues.push_back(std::make_pair(values, timeSteps));
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RiaCurveDataTools::CurveIntervals RiaTimeHistoryCurveMerger::validIntervalsForAllTimeSteps() const
+{
+    return m_validIntervalsForAllTimeSteps;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<time_t>& RiaTimeHistoryCurveMerger::allTimeSteps() const
+{
+    return m_allTimeSteps;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>& RiaTimeHistoryCurveMerger::interpolatedCurveValuesForAllTimeSteps(size_t curveIdx) const
+{
+    CVF_ASSERT(curveIdx < m_interpolatedValuesForAllCurves.size());
+
+    return m_interpolatedValuesForAllCurves[curveIdx];
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<double>& RiaTimeHistoryCurveMerger::interpolatedCurveValuesForAllTimeSteps(size_t curveIdx)
+{
+    CVF_ASSERT(curveIdx < m_interpolatedValuesForAllCurves.size());
+
+    return m_interpolatedValuesForAllCurves[curveIdx];
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+int RiaTimeHistoryCurveMerger::interploatedCurveCount() const
+{
+    return static_cast<int>(m_interpolatedValuesForAllCurves.size());
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiaTimeHistoryCurveMerger::computeInterpolatedValues()
+{
+    m_validIntervalsForAllTimeSteps.clear();
+    m_allTimeSteps.clear();
+    m_interpolatedValuesForAllCurves.clear();
+
+    computeUnionOfTimeSteps();
+
+    const size_t curveCount = m_originalValues.size();
+    if (curveCount == 0)
+    {
+        return;
+    }
+
+    const size_t dataValueCount = m_allTimeSteps.size();
+    if (dataValueCount == 0)
+    {
+        return;
+    }
+
+    m_interpolatedValuesForAllCurves.resize(curveCount);
+
+    std::vector<double> accumulatedValidValues(dataValueCount, 1.0);
+
+    for (size_t curveIdx = 0; curveIdx < curveCount; curveIdx++)
+    {
+        std::vector<double>& curveValues = m_interpolatedValuesForAllCurves[curveIdx];
+        curveValues.resize(dataValueCount);
+
+        for (size_t valueIndex = 0; valueIndex < dataValueCount; valueIndex++)
+        {
+            double interpolValue = interpolationValue(m_allTimeSteps[valueIndex], m_originalValues[curveIdx].first, m_originalValues[curveIdx].second);
+            if (!RiaCurveDataTools::isValidValue(interpolValue, false))
+            {
+                accumulatedValidValues[valueIndex] = HUGE_VAL;
+            }
+
+            curveValues[valueIndex] = interpolValue;
+        }
+    }
+
+    m_validIntervalsForAllTimeSteps = RiaCurveDataTools::calculateIntervalsOfValidValues(accumulatedValidValues, false);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiaTimeHistoryCurveMerger::computeUnionOfTimeSteps()
+{
+    m_allTimeSteps.clear();
+
+    std::set<time_t> unionOfTimeSteps;
+
+    for (const auto& curveData : m_originalValues)
+    {
+        for (const auto& dt : curveData.second)
+        {
+            unionOfTimeSteps.insert(dt);
+        }
+    }
+
+    for (const auto& dt : unionOfTimeSteps)
+    {
+        m_allTimeSteps.push_back(dt);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+double RiaTimeHistoryCurveMerger::interpolationValue(const time_t& interpolationTimeStep,
+                                                     const std::vector<double>& curveValues, 
+                                                     const std::vector<time_t>& curveTimeSteps)
+{
+    if (curveValues.size() != curveTimeSteps.size()) return HUGE_VAL;
+
+    const bool removeInterpolatedValues = false;
+
+    for (size_t firstI = 0; firstI < curveTimeSteps.size(); firstI++)
+    {
+        if (curveTimeSteps.at(firstI) == interpolationTimeStep)
+        {
+            const double& firstValue = curveValues.at(firstI);
+            if (!RiaCurveDataTools::isValidValue(firstValue, removeInterpolatedValues))
+            {
+                return HUGE_VAL;
+            }
+
+            return firstValue;
+        }
+
+        size_t secondI = firstI + 1;
+
+        if (secondI < curveTimeSteps.size() &&
+            curveTimeSteps.at(firstI) <= interpolationTimeStep &&
+            curveTimeSteps.at(secondI) > interpolationTimeStep)
+        {
+            if (curveTimeSteps.at(secondI) == interpolationTimeStep)
+            {
+                const double& secondValue = curveValues.at(secondI);
+                if (!RiaCurveDataTools::isValidValue(secondValue, removeInterpolatedValues))
+                {
+                    return HUGE_VAL;
+                }
+
+                return secondValue;
+            }
+
+            const double& firstValue = curveValues.at(firstI);
+            const double& secondValue = curveValues.at(secondI);
+
+            bool isFirstValid = RiaCurveDataTools::isValidValue(firstValue, removeInterpolatedValues);
+            if (!isFirstValid) return HUGE_VAL;
+
+            bool isSecondValid = RiaCurveDataTools::isValidValue(secondValue, removeInterpolatedValues);
+            if (!isSecondValid) return HUGE_VAL;
+
+            double firstDiff = fabs(difftime(interpolationTimeStep, curveTimeSteps.at(firstI)));
+            double secondDiff = fabs(difftime(curveTimeSteps.at(secondI), interpolationTimeStep));
+
+            double firstWeight = secondDiff / (firstDiff + secondDiff);
+            double secondWeight = firstDiff / (firstDiff + secondDiff);
+
+            double val = (firstValue * firstWeight) + (secondValue * secondWeight);
+
+            CVF_ASSERT(RiaCurveDataTools::isValidValue(val, removeInterpolatedValues));
+
+            return val;
+        }
+    }
+
+    return HUGE_VAL;
+}
+

ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.h

@@ -0,0 +1,69 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2017     Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "RiaCurveDataTools.h"
+
+#include <ctime>
+
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RiaTimeHistoryCurveMerger
+{
+public:
+    RiaTimeHistoryCurveMerger();
+
+
+    void                                addCurveData(const std::vector<double>& values, 
+                                                     const std::vector<time_t>& timeSteps);
+
+    void                                computeInterpolatedValues();
+
+    RiaCurveDataTools::CurveIntervals   validIntervalsForAllTimeSteps() const;
+    const std::vector<time_t>&          allTimeSteps() const;
+    const std::vector<double>&          interpolatedCurveValuesForAllTimeSteps(size_t curveIdx) const;
+    int                                 interploatedCurveCount() const;
+
+    // Non-const access is not required by any clients, but the expression parser has no available const interface
+    // for specifying a data source for an expression variable. Allow non-const access to avoid copy of the contained 
+    // values, interpolated for all time steps
+    //
+    // See ExpressionParserImpl::assignVector()
+    std::vector<double>&                interpolatedCurveValuesForAllTimeSteps(size_t curveIdx);
+
+public:
+    // Helper methods, available as public to be able to access from unit tests
+
+    static double interpolationValue(const time_t& interpolationTimeStep,
+                                     const std::vector<double>& curveValues, 
+                                     const std::vector<time_t>& curveTimeSteps);
+
+private:
+    void computeUnionOfTimeSteps();
+
+private:
+    std::vector<std::pair<std::vector<double>, std::vector<time_t>>> m_originalValues;
+
+    RiaCurveDataTools::CurveIntervals   m_validIntervalsForAllTimeSteps;
+
+    std::vector<time_t>                 m_allTimeSteps;
+    std::vector<std::vector<double>>    m_interpolatedValuesForAllCurves;
+};

ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp

@@ -21,7 +21,7 @@
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 #include "RigWellPath.h"
 #include "RigWellPathGeometryTools.h"
 
@@ -129,7 +129,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
 
     for (double& result : m_curveValues)
     {
-        if (!RigCurveDataTools::isValidValue(result, false)) continue;
+        if (!RiaCurveDataTools::isValidValue(result, false)) continue;
 
         if ((minCurveValue - result) > curveEpsilon * curveUIRange)
         {
@@ -158,7 +158,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
     {
         double scaledResult = 0;
 
-        if (RigCurveDataTools::isValidValue(m_curveValues[i], false))
+        if (RiaCurveDataTools::isValidValue(m_curveValues[i], false))
         {
             scaledResult = planeOffsetFromWellPathCenter + (m_curveValues[i] - minCurveValue) * plotRangeToResultRangeFactor;
         }
@@ -174,8 +174,8 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
         indices.reserve(m_curveVertices.size() * 2);
         for (size_t i = 0; i < m_curveVertices.size() - 1; ++i)
         {
-            if (RigCurveDataTools::isValidValue(m_curveValues[i], false) &&
+            if (RiaCurveDataTools::isValidValue(m_curveValues[i], false) &&
-                RigCurveDataTools::isValidValue(m_curveValues[i + 1], false))
+                RiaCurveDataTools::isValidValue(m_curveValues[i + 1], false))
             {
                 if (cvf::Math::valueInRange(m_curveValues[i], minCurveValue, maxCurveValue) ||
                     cvf::Math::valueInRange(m_curveValues[i + 1], minCurveValue, maxCurveValue))
@@ -246,8 +246,8 @@ bool Riv3dWellLogCurveGeometryGenerator::findClosestPointOnCurve(const cvf::Vec3
     CVF_ASSERT(m_curveVertices.size() == m_curveValues.size());
     for (size_t i = 1; i < m_curveVertices.size(); ++i)
     {
-        bool validCurveSegment = RigCurveDataTools::isValidValue(m_curveValues[i], false) &&
+        bool validCurveSegment = RiaCurveDataTools::isValidValue(m_curveValues[i], false) &&
-                                 RigCurveDataTools::isValidValue(m_curveValues[i - 1], false);
+                                 RiaCurveDataTools::isValidValue(m_curveValues[i - 1], false);
         if (validCurveSegment)
         {
             cvf::Vec3d a  = m_curveVertices[i - 1];
@@ -290,8 +290,8 @@ void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongTriangleEdges(con
 
     for (size_t i = 0; i < m_curveVertices.size() - 1; i += 2)
     {
-        if (RigCurveDataTools::isValidValue(m_curveValues[i], false) &&
+        if (RiaCurveDataTools::isValidValue(m_curveValues[i], false) &&
-            RigCurveDataTools::isValidValue(m_curveValues[i + 1], false))
+            RiaCurveDataTools::isValidValue(m_curveValues[i + 1], false))
         {
             cvf::Vec3d lastVertex        = m_curveVertices[i];
             cvf::Vec3d fullSegmentVector = m_curveVertices[i + 1] - m_curveVertices[i];

ApplicationCode/ProjectDataModel/Rim3dWellLogCurve.cpp

@@ -18,7 +18,7 @@
 
 #include "Rim3dWellLogCurve.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 #include "Riv3dWellLogCurveGeometryGenerator.h"
 
 #include "Rim3dWellLogCurveCollection.h"
@@ -268,7 +268,7 @@ void Rim3dWellLogCurve::resetMinMaxValues()
     double foundMaxValue = -std::numeric_limits<float>::infinity();
     for (double value : values)
     {
-        if (RigCurveDataTools::isValidValue(value, false))
+        if (RiaCurveDataTools::isValidValue(value, false))
         {
             foundMinValue = std::min(foundMinValue, value);
             foundMaxValue = std::max(foundMaxValue, value);

ApplicationCode/ProjectDataModel/RimSummaryCalculation.cpp

@@ -23,7 +23,7 @@
 #include "RiaSummaryCurveDefinition.h"
 #include "RiaSummaryTools.h"
 
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include "RimProject.h"
 #include "RimSummaryAddress.h"
@@ -240,7 +240,7 @@ bool RimSummaryCalculation::calculate()
 {
     QString leftHandSideVariableName = RimSummaryCalculation::findLeftHandSide(m_expression);
 
-    RigTimeHistoryCurveMerger timeHistoryCurveMerger;
+    RiaTimeHistoryCurveMerger timeHistoryCurveMerger;
 
     for (size_t i = 0; i < m_variables.size(); i++)
     {

ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp

@@ -27,7 +27,7 @@
 #include "RifReaderEclipseSummary.h"
 
 #include "RigStatisticsMath.h"
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include "RimEnsembleCurveFilter.h"
 #include "RimEnsembleCurveFilterCollection.h"

ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatistics.cpp

@@ -21,7 +21,7 @@
 #include "RifSummaryReaderInterface.h"
 
 #include "RigStatisticsMath.h"
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include "RimEnsembleCurveSet.h"
 #include "RimSummaryCase.h"

ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp

@@ -21,7 +21,7 @@
 #include "RifEnsembleStatisticsReader.h"
 
 #include "RigStatisticsMath.h"
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include "RimEnsembleCurveSet.h"
 
@@ -111,7 +111,7 @@ const RimEnsembleCurveSet* RimEnsembleStatisticsCase::curveSet() const
 //--------------------------------------------------------------------------------------------------
 void RimEnsembleStatisticsCase::calculate(const RimSummaryCaseCollection* ensemble, const RifEclipseSummaryAddress& inputAddress)
 {
-    RigTimeHistoryCurveMerger curveMerger;
+    RiaTimeHistoryCurveMerger curveMerger;
     int caseCount = (int)ensemble->allSummaryCases().size();
 
     {

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp

@@ -23,7 +23,7 @@
 
 #include "RifReaderEclipseSummary.h"
 
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include "RimEclipseResultCase.h"
 #include "RimProject.h"
@@ -433,7 +433,7 @@ void RimSummaryCurve::onLoadDataAndUpdate(bool updateParentPlot)
             }
             else
             {
-                RigTimeHistoryCurveMerger curveMerger;
+                RiaTimeHistoryCurveMerger curveMerger;
                 curveMerger.addCurveData(curveValuesX, curveTimeStepsX);
                 curveMerger.addCurveData(curveValuesY, curveTimeStepsY);
                 curveMerger.computeInterpolatedValues();
@@ -771,7 +771,7 @@ void RimSummaryCurve::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
 
         if (!curveValuesX.empty() && !curveValuesY.empty())
         {
-            RigTimeHistoryCurveMerger curveMerger;
+            RiaTimeHistoryCurveMerger curveMerger;
             curveMerger.addCurveData(curveValuesX, curveTimeStepsX);
             curveMerger.addCurveData(curveValuesY, curveTimeStepsY);
             curveMerger.computeInterpolatedValues();

ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake

@@ -45,7 +45,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RigWellLogCurveData.h
 ${CMAKE_CURRENT_LIST_DIR}/RigWellLogExtractionTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RigHexIntersectionTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RigTimeHistoryResultAccessor.h
-${CMAKE_CURRENT_LIST_DIR}/RigCurveDataTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RigObservedData.h
 ${CMAKE_CURRENT_LIST_DIR}/RigLasFileExporter.h
 ${CMAKE_CURRENT_LIST_DIR}/RigSimulationWellCoordsAndMD.h
@@ -58,7 +57,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RigTofAccumulatedPhaseFractionsCalculator.h
 ${CMAKE_CURRENT_LIST_DIR}/RigTransmissibilityEquations.h
 ${CMAKE_CURRENT_LIST_DIR}/RigNumberOfFloodedPoreVolumesCalculator.h
 ${CMAKE_CURRENT_LIST_DIR}/RigWeightedMeanCalc.h
-${CMAKE_CURRENT_LIST_DIR}/RigTimeHistoryCurveMerger.h
 ${CMAKE_CURRENT_LIST_DIR}/RigWellPathFormations.h
 ${CMAKE_CURRENT_LIST_DIR}/RigStimPlanFractureDefinition.h
 ${CMAKE_CURRENT_LIST_DIR}/RigFractureGrid.h
@@ -111,7 +109,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RigEclipseMultiPropertyStatCalc.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigWellLogCurveData.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigHexIntersectionTools.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigTimeHistoryResultAccessor.cpp
-${CMAKE_CURRENT_LIST_DIR}/RigCurveDataTools.cpp    
 ${CMAKE_CURRENT_LIST_DIR}/RigObservedData.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigLasFileExporter.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigSimulationWellCoordsAndMD.cpp
@@ -124,7 +121,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RigTofAccumulatedPhaseFractionsCalculator.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigTransmissibilityEquations.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigNumberOfFloodedPoreVolumesCalculator.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigWeightedMeanCalc.cpp
-${CMAKE_CURRENT_LIST_DIR}/RigTimeHistoryCurveMerger.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigWellPathFormations.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigStimPlanFractureDefinition.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigFractureGrid.cpp

ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp

@@ -19,7 +19,7 @@
 
 #include "RigWellLogCurveData.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 
 #include "RiaEclipseUnitTools.h"
 
@@ -118,7 +118,7 @@ const std::vector<double>& RigWellLogCurveData::tvDepths() const
 std::vector<double> RigWellLogCurveData::xPlotValues() const
 {
     std::vector<double> filteredValues;
-    RigCurveDataTools::getValuesByIntervals(m_xValues, m_intervalsOfContinousValidValues, &filteredValues);
+    RiaCurveDataTools::getValuesByIntervals(m_xValues, m_intervalsOfContinousValidValues, &filteredValues);
 
     return filteredValues;
 }
@@ -133,12 +133,12 @@ std::vector<double> RigWellLogCurveData::trueDepthPlotValues(RiaDefines::DepthUn
     {
         if(destinationDepthUnit == m_depthUnit)
         {
-            RigCurveDataTools::getValuesByIntervals(m_tvDepths, m_intervalsOfContinousValidValues, &filteredValues);
+            RiaCurveDataTools::getValuesByIntervals(m_tvDepths, m_intervalsOfContinousValidValues, &filteredValues);
         }
         else
         {
             std::vector<double> convertedValues = convertDepthValues(destinationDepthUnit, m_tvDepths);
-            RigCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues);
+            RiaCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues);
         }
     }
 
@@ -154,12 +154,12 @@ std::vector<double> RigWellLogCurveData::measuredDepthPlotValues(RiaDefines::Dep
 
     if(destinationDepthUnit == m_depthUnit)
     {
-        RigCurveDataTools::getValuesByIntervals(m_measuredDepths, m_intervalsOfContinousValidValues, &filteredValues);
+        RiaCurveDataTools::getValuesByIntervals(m_measuredDepths, m_intervalsOfContinousValidValues, &filteredValues);
     }
     else
     {
         std::vector<double> convertedValues = convertDepthValues(destinationDepthUnit, m_measuredDepths);
-        RigCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues);
+        RiaCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues);
     }
 
     return filteredValues;
@@ -170,7 +170,7 @@ std::vector<double> RigWellLogCurveData::measuredDepthPlotValues(RiaDefines::Dep
 //--------------------------------------------------------------------------------------------------
 std::vector<std::pair<size_t, size_t>> RigWellLogCurveData::polylineStartStopIndices() const
 {
-    return RigCurveDataTools::computePolyLineStartStopIndices(m_intervalsOfContinousValidValues);
+    return RiaCurveDataTools::computePolyLineStartStopIndices(m_intervalsOfContinousValidValues);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -246,7 +246,7 @@ cvf::ref<RigWellLogCurveData> RigWellLogCurveData::calculateResampledCurveData(d
 //--------------------------------------------------------------------------------------------------
 void RigWellLogCurveData::calculateIntervalsOfContinousValidValues()
 {
-    std::vector<std::pair<size_t, size_t>> intervalsOfValidValues = RigCurveDataTools::calculateIntervalsOfValidValues(m_xValues, false);
+    std::vector<std::pair<size_t, size_t>> intervalsOfValidValues = RiaCurveDataTools::calculateIntervalsOfValidValues(m_xValues, false);
 
     m_intervalsOfContinousValidValues.clear();
 

ApplicationCode/UnitTests/RigTimeCurveHistoryMerger-Test.cpp

@@ -1,37 +1,37 @@
 #include "gtest/gtest.h"
 
-#include "RigTimeHistoryCurveMerger.h"
+#include "RiaTimeHistoryCurveMerger.h"
 
 #include <cmath> // Needed for HUGE_VAL on Linux
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-TEST(RigTimeHistoryCurveMergerTest, TestDateInterpolation)
+TEST(RiaTimeHistoryCurveMergerTest, TestDateInterpolation)
 {
     std::vector<double>    values{  2.0, 3.5, 5.0, 6.0};
     std::vector<time_t> timeSteps{    1,   5,  10,  15};
 
     {
-        double val = RigTimeHistoryCurveMerger::interpolationValue(1, values, timeSteps);
+        double val = RiaTimeHistoryCurveMerger::interpolationValue(1, values, timeSteps);
 
         EXPECT_EQ(2.0, val);
     }
 
     {
-        double val = RigTimeHistoryCurveMerger::interpolationValue(0, values, timeSteps);
+        double val = RiaTimeHistoryCurveMerger::interpolationValue(0, values, timeSteps);
 
         EXPECT_EQ(HUGE_VAL, val);
     }
 
     {
-        double val = RigTimeHistoryCurveMerger::interpolationValue(20, values, timeSteps);
+        double val = RiaTimeHistoryCurveMerger::interpolationValue(20, values, timeSteps);
 
         EXPECT_EQ(HUGE_VAL, val);
     }
 
     {
-        double val = RigTimeHistoryCurveMerger::interpolationValue(3, values, timeSteps);
+        double val = RiaTimeHistoryCurveMerger::interpolationValue(3, values, timeSteps);
 
         EXPECT_EQ(2.75, val);
     }
@@ -40,7 +40,7 @@ TEST(RigTimeHistoryCurveMergerTest, TestDateInterpolation)
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeSteps) 
+TEST(RiaTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeSteps) 
 { 
     std::vector<double> valuesA { HUGE_VAL, 1.0, HUGE_VAL, 2.0, 2.5,      3.0,      4.0, 5.0, 6.0, HUGE_VAL }; 
     std::vector<double> valuesB {       10,  20,       30,  40,  45, HUGE_VAL, HUGE_VAL, 5.0, 6.0, HUGE_VAL }; 
@@ -53,7 +53,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeSteps)
         timeSteps.push_back(i);
     }
 
-    RigTimeHistoryCurveMerger interpolate;
+    RiaTimeHistoryCurveMerger interpolate;
     interpolate.addCurveData(valuesA, timeSteps);
     interpolate.addCurveData(valuesB, timeSteps);
     interpolate.computeInterpolatedValues();
@@ -68,7 +68,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeSteps)
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsOneComplete) 
+TEST(RiaTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsOneComplete) 
 { 
     std::vector<double> valuesA { 1.0, 2.0, 3.0,      4.0, 5.0,     6.0, 7.0 }; 
     std::vector<double> valuesB {  10,  20,  30, HUGE_VAL,  50, HUGE_VAL, 70 }; 
@@ -81,7 +81,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsOneComplete
         timeSteps.push_back(i);
     }
 
-    RigTimeHistoryCurveMerger interpolate;
+    RiaTimeHistoryCurveMerger interpolate;
     interpolate.addCurveData(valuesA, timeSteps);
     interpolate.addCurveData(valuesB, timeSteps);
     interpolate.computeInterpolatedValues();
@@ -96,7 +96,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsOneComplete
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsBothComplete)
+TEST(RiaTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsBothComplete)
 {
     std::vector<double> valuesA{ 1.0, 2.0, 3.0,      4.0, 5.0,     6.0, 7.0 };
     std::vector<double> valuesB{ 10,  20,  30,        40,  50,      60,  70 };
@@ -109,7 +109,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsBothComplet
         timeSteps.push_back(i);
     }
 
-    RigTimeHistoryCurveMerger interpolate;
+    RiaTimeHistoryCurveMerger interpolate;
     interpolate.addCurveData(valuesA, timeSteps);
     interpolate.addCurveData(valuesB, timeSteps);
     interpolate.computeInterpolatedValues();
@@ -124,7 +124,7 @@ TEST(RigTimeHistoryCurveMergerTest, ExtractIntervalsWithSameTimeStepsBothComplet
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, OverlappintTimes)
+TEST(RiaTimeHistoryCurveMergerTest, OverlappintTimes)
 {
     std::vector<double> valuesA{  1,  2,  3,  4,  5 };
     std::vector<double> valuesB{ 10, 20, 30, 40, 50 };
@@ -134,7 +134,7 @@ TEST(RigTimeHistoryCurveMergerTest, OverlappintTimes)
     std::vector<time_t> timeStepsA{ 0, 10, 11, 15, 20 };
     std::vector<time_t> timeStepsB{ 1, 2, 3, 5, 7 };
 
-    RigTimeHistoryCurveMerger interpolate;
+    RiaTimeHistoryCurveMerger interpolate;
     interpolate.addCurveData(valuesA, timeStepsA);
     interpolate.addCurveData(valuesB, timeStepsB);
     interpolate.computeInterpolatedValues();
@@ -149,10 +149,10 @@ TEST(RigTimeHistoryCurveMergerTest, OverlappintTimes)
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, RobustUse)
+TEST(RiaTimeHistoryCurveMergerTest, RobustUse)
 {
     {
-        RigTimeHistoryCurveMerger curveMerger;
+        RiaTimeHistoryCurveMerger curveMerger;
         curveMerger.computeInterpolatedValues();
         EXPECT_EQ(0, static_cast<int>(curveMerger.allTimeSteps().size()));
     }
@@ -164,7 +164,7 @@ TEST(RigTimeHistoryCurveMergerTest, RobustUse)
     std::vector<time_t> timeStepsB{ 1, 2, 3 };
 
     {
-        RigTimeHistoryCurveMerger curveMerger;
+        RiaTimeHistoryCurveMerger curveMerger;
         curveMerger.addCurveData(valuesA, timeStepsA);
         curveMerger.computeInterpolatedValues();
         EXPECT_EQ(timeStepsA.size(), curveMerger.allTimeSteps().size());
@@ -172,7 +172,7 @@ TEST(RigTimeHistoryCurveMergerTest, RobustUse)
     }
 
     {
-        RigTimeHistoryCurveMerger curveMerger;
+        RiaTimeHistoryCurveMerger curveMerger;
         curveMerger.addCurveData(valuesA, timeStepsA);
         curveMerger.addCurveData(valuesB, timeStepsB);
 
@@ -188,7 +188,7 @@ TEST(RigTimeHistoryCurveMergerTest, RobustUse)
 //-------------------------------------------------------------------------------------------------- 
 ///  
 //-------------------------------------------------------------------------------------------------- 
-TEST(RigTimeHistoryCurveMergerTest, NoTimeStepOverlap)
+TEST(RiaTimeHistoryCurveMergerTest, NoTimeStepOverlap)
 {
     std::vector<double> valuesA{ 1,  2,  3,  4,  5 };
     std::vector<double> valuesB{ 10, 20, 30 };
@@ -197,7 +197,7 @@ TEST(RigTimeHistoryCurveMergerTest, NoTimeStepOverlap)
     std::vector<time_t> timeStepsB{ 100, 200, 300 };
 
     {
-        RigTimeHistoryCurveMerger curveMerger;
+        RiaTimeHistoryCurveMerger curveMerger;
         curveMerger.addCurveData(valuesA, timeStepsA);
         curveMerger.addCurveData(valuesB, timeStepsB);
 

ApplicationCode/UnitTests/RimWellLogExtractionCurveImpl-Test.cpp

@@ -1,6 +1,6 @@
 #include "gtest/gtest.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 
 #include <cmath> // Needed for HUGE_VAL on Linux
 #include <numeric>
@@ -19,7 +19,7 @@ TEST(RimWellLogExtractionCurveImplTest, StripOffInvalidValAtEndsOfVector)
     values.push_back(3.0);
     values.push_back(HUGE_VAL);
 
-    auto valuesIntervals = RigCurveDataTools::calculateIntervalsOfValidValues(values, false);
+    auto valuesIntervals = RiaCurveDataTools::calculateIntervalsOfValidValues(values, false);
 
     EXPECT_EQ(1, static_cast<int>(valuesIntervals.size()));
     EXPECT_EQ(2, static_cast<int>(valuesIntervals[0].first));
@@ -42,7 +42,7 @@ TEST(RimWellLogExtractionCurveImplTest, StripOffHugeValAtEndsAndInteriorOfVector
     values.push_back(3.0);
     values.push_back(HUGE_VAL);
 
-    auto valuesIntervals = RigCurveDataTools::calculateIntervalsOfValidValues(values, false);
+    auto valuesIntervals = RiaCurveDataTools::calculateIntervalsOfValidValues(values, false);
 
     EXPECT_EQ(2, static_cast<int>(valuesIntervals.size()));
     EXPECT_EQ(2, static_cast<int>(valuesIntervals[0].first));

ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.cpp

@@ -20,7 +20,7 @@
 #include "RiuLineSegmentQwtPlotCurve.h"
 
 #include "qwt_symbol.h"
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 #include "qwt_date.h"
 #include "qwt_point_mapper.h"
 #include "qwt_painter.h"
@@ -77,14 +77,14 @@ void RiuLineSegmentQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vect
         std::vector<double> filteredYErrorValues;
 
         {
-            auto intervalsOfValidValues = RigCurveDataTools::calculateIntervalsOfValidValues(yValues, keepOnlyPositiveValues);
+            auto intervalsOfValidValues = RiaCurveDataTools::calculateIntervalsOfValidValues(yValues, keepOnlyPositiveValues);
 
-            RigCurveDataTools::getValuesByIntervals(yValues, intervalsOfValidValues, &filteredYValues);
+            RiaCurveDataTools::getValuesByIntervals(yValues, intervalsOfValidValues, &filteredYValues);
-            RigCurveDataTools::getValuesByIntervals(xValues, intervalsOfValidValues, &filteredXValues);
+            RiaCurveDataTools::getValuesByIntervals(xValues, intervalsOfValidValues, &filteredXValues);
 
-            if(showErrorBars) RigCurveDataTools::getValuesByIntervals(yErrorValues, intervalsOfValidValues, &filteredYErrorValues);
+            if(showErrorBars) RiaCurveDataTools::getValuesByIntervals(yErrorValues, intervalsOfValidValues, &filteredYErrorValues);
 
-            filteredIntervals = RigCurveDataTools::computePolyLineStartStopIndices(intervalsOfValidValues);
+            filteredIntervals = RiaCurveDataTools::computePolyLineStartStopIndices(intervalsOfValidValues);
         }
 
         points.reserve(static_cast<int>(filteredXValues.size()));

ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp

@@ -22,7 +22,7 @@
 #include "RiuLineSegmentQwtPlotCurve.h"
 #include "RiuTextDialog.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 #include "RigFlowDiagSolverInterface.h"
 
 #include "cvfBase.h"
@@ -246,7 +246,7 @@ void RiuRelativePermeabilityPlotPanel::addTransparentCurve(QwtPlot* plot, const
 
     for (size_t i = 0; i < points.size(); i++)
     {
-        if (!RigCurveDataTools::isValidValue(points[i].y(), logScaleLeftAxis)) continue;
+        if (!RiaCurveDataTools::isValidValue(points[i].y(), logScaleLeftAxis)) continue;
         
         if (axes[i] == LEFT_YAXIS)
         {

ApplicationCode/UserInterface/RiuResultQwtPlot.cpp

@@ -19,7 +19,7 @@
 
 #include "RiuResultQwtPlot.h"
 
-#include "RigCurveDataTools.h"
+#include "RiaCurveDataTools.h"
 
 #include "RimContextCommandBuilder.h"
 #include "RimCase.h"