From eebd8bef2de21914f701f1ff3cd0e8254e83d644 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Jensen?= Date: Fri, 8 Jun 2018 15:10:45 +0200 Subject: [PATCH] Move RigCurveDataTools and RigTimeHistoryCurveMerger to Application/Tools plus rename --- .../Application/Tools/CMakeLists_files.cmake | 4 + .../Application/Tools/RiaCurveDataTools.cpp | 107 +++++++++ .../Application/Tools/RiaCurveDataTools.h | 65 +++++ .../Tools/RiaTimeHistoryCurveMerger.cpp | 223 ++++++++++++++++++ .../Tools/RiaTimeHistoryCurveMerger.h | 69 ++++++ .../Riv3dWellLogCurveGeometryGenerator.cpp | 18 +- .../ProjectDataModel/Rim3dWellLogCurve.cpp | 4 +- .../RimSummaryCalculation.cpp | 4 +- .../Summary/RimEnsembleCurveSet.cpp | 2 +- .../Summary/RimEnsembleStatistics.cpp | 2 +- .../Summary/RimEnsembleStatisticsCase.cpp | 4 +- .../Summary/RimSummaryCurve.cpp | 6 +- .../ReservoirDataModel/CMakeLists_files.cmake | 4 - .../RigWellLogCurveData.cpp | 16 +- .../RigTimeCurveHistoryMerger-Test.cpp | 40 ++-- .../RimWellLogExtractionCurveImpl-Test.cpp | 6 +- .../RiuLineSegmentQwtPlotCurve.cpp | 12 +- .../RiuRelativePermeabilityPlotPanel.cpp | 4 +- .../UserInterface/RiuResultQwtPlot.cpp | 2 +- 19 files changed, 528 insertions(+), 64 deletions(-) create mode 100644 ApplicationCode/Application/Tools/RiaCurveDataTools.cpp create mode 100644 ApplicationCode/Application/Tools/RiaCurveDataTools.h create mode 100644 ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.cpp create mode 100644 ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.h diff --git a/ApplicationCode/Application/Tools/CMakeLists_files.cmake b/ApplicationCode/Application/Tools/CMakeLists_files.cmake index 06095bc398..6493cf2d82 100644 --- a/ApplicationCode/Application/Tools/CMakeLists_files.cmake +++ b/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 diff --git a/ApplicationCode/Application/Tools/RiaCurveDataTools.cpp b/ApplicationCode/Application/Tools/RiaCurveDataTools.cpp new file mode 100644 index 0000000000..60aefcf7c9 --- /dev/null +++ b/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 +// for more details. +// +///////////////////////////////////////////////////////////////////////////////// + +#include "RiaCurveDataTools.h" + + +#include // Needed for HUGE_VAL on Linux + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +RiaCurveDataTools::CurveIntervals RiaCurveDataTools::calculateIntervalsOfValidValues(const std::vector& 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> RiaCurveDataTools::computePolyLineStartStopIndices(const CurveIntervals& intervals) +{ + std::vector> 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; +} + diff --git a/ApplicationCode/Application/Tools/RiaCurveDataTools.h b/ApplicationCode/Application/Tools/RiaCurveDataTools.h new file mode 100644 index 0000000000..1dc9550058 --- /dev/null +++ b/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 +// for more details. +// +///////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#include "cvfAssert.h" + +#include +#include +#include +#include + +class QDateTime; + + +//================================================================================================== +/// +//================================================================================================== +class RiaCurveDataTools +{ +public: + typedef std::vector> CurveIntervals; + +public: + static CurveIntervals calculateIntervalsOfValidValues(const std::vector& values, + bool includePositiveValuesOnly); + + template + static void getValuesByIntervals(const std::vector& values, + const CurveIntervals& intervals, + std::vector* 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> computePolyLineStartStopIndices(const CurveIntervals& intervals); + +public: + static bool isValidValue(double value, bool allowPositiveValuesOnly); +}; + diff --git a/ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.cpp b/ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.cpp new file mode 100644 index 0000000000..258c1e9dc8 --- /dev/null +++ b/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 +// for more details. +// +///////////////////////////////////////////////////////////////////////////////// + +#include "RiaTimeHistoryCurveMerger.h" + + +#include // Needed for HUGE_VAL on Linux + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +RiaTimeHistoryCurveMerger::RiaTimeHistoryCurveMerger() +{ + +} + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void RiaTimeHistoryCurveMerger::addCurveData(const std::vector& values, const std::vector& 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& RiaTimeHistoryCurveMerger::allTimeSteps() const +{ + return m_allTimeSteps; +} + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +const std::vector& RiaTimeHistoryCurveMerger::interpolatedCurveValuesForAllTimeSteps(size_t curveIdx) const +{ + CVF_ASSERT(curveIdx < m_interpolatedValuesForAllCurves.size()); + + return m_interpolatedValuesForAllCurves[curveIdx]; +} + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +std::vector& RiaTimeHistoryCurveMerger::interpolatedCurveValuesForAllTimeSteps(size_t curveIdx) +{ + CVF_ASSERT(curveIdx < m_interpolatedValuesForAllCurves.size()); + + return m_interpolatedValuesForAllCurves[curveIdx]; +} + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +int RiaTimeHistoryCurveMerger::interploatedCurveCount() const +{ + return static_cast(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 accumulatedValidValues(dataValueCount, 1.0); + + for (size_t curveIdx = 0; curveIdx < curveCount; curveIdx++) + { + std::vector& 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 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& curveValues, + const std::vector& 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; +} + diff --git a/ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.h b/ApplicationCode/Application/Tools/RiaTimeHistoryCurveMerger.h new file mode 100644 index 0000000000..6dc41170fd --- /dev/null +++ b/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 +// for more details. +// +///////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#include "RiaCurveDataTools.h" + +#include + + +//================================================================================================== +/// +//================================================================================================== +class RiaTimeHistoryCurveMerger +{ +public: + RiaTimeHistoryCurveMerger(); + + + void addCurveData(const std::vector& values, + const std::vector& timeSteps); + + void computeInterpolatedValues(); + + RiaCurveDataTools::CurveIntervals validIntervalsForAllTimeSteps() const; + const std::vector& allTimeSteps() const; + const std::vector& 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& 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& curveValues, + const std::vector& curveTimeSteps); + +private: + void computeUnionOfTimeSteps(); + +private: + std::vector, std::vector>> m_originalValues; + + RiaCurveDataTools::CurveIntervals m_validIntervalsForAllTimeSteps; + + std::vector m_allTimeSteps; + std::vector> m_interpolatedValuesForAllCurves; +}; diff --git a/ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp b/ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp index 26385a699e..7f061cc9ba 100644 --- a/ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp +++ b/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) && - RigCurveDataTools::isValidValue(m_curveValues[i + 1], false)) + if (RiaCurveDataTools::isValidValue(m_curveValues[i], 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) && - RigCurveDataTools::isValidValue(m_curveValues[i - 1], false); + bool validCurveSegment = RiaCurveDataTools::isValidValue(m_curveValues[i], 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) && - RigCurveDataTools::isValidValue(m_curveValues[i + 1], false)) + if (RiaCurveDataTools::isValidValue(m_curveValues[i], false) && + RiaCurveDataTools::isValidValue(m_curveValues[i + 1], false)) { cvf::Vec3d lastVertex = m_curveVertices[i]; cvf::Vec3d fullSegmentVector = m_curveVertices[i + 1] - m_curveVertices[i]; diff --git a/ApplicationCode/ProjectDataModel/Rim3dWellLogCurve.cpp b/ApplicationCode/ProjectDataModel/Rim3dWellLogCurve.cpp index 8696932038..b6ebcf595c 100644 --- a/ApplicationCode/ProjectDataModel/Rim3dWellLogCurve.cpp +++ b/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::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); diff --git a/ApplicationCode/ProjectDataModel/RimSummaryCalculation.cpp b/ApplicationCode/ProjectDataModel/RimSummaryCalculation.cpp index 9ec7e9117e..71c74a689b 100644 --- a/ApplicationCode/ProjectDataModel/RimSummaryCalculation.cpp +++ b/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++) { diff --git a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp b/ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp index 01f2ce20ab..bdd958ab89 100644 --- a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp +++ b/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" diff --git a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatistics.cpp b/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatistics.cpp index 94e6d1b6db..5eb2ba46f4 100644 --- a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatistics.cpp +++ b/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" diff --git a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp b/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp index 8c35157d24..229d29b5c5 100644 --- a/ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp +++ b/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(); { diff --git a/ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp b/ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp index 798b1e60db..5694b00dd2 100644 --- a/ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp +++ b/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(); diff --git a/ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake b/ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake index 167f2c6a9c..92817a9752 100644 --- a/ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake +++ b/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 diff --git a/ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp b/ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp index 674a6bc46d..75a54ba227 100644 --- a/ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp +++ b/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& RigWellLogCurveData::tvDepths() const std::vector RigWellLogCurveData::xPlotValues() const { std::vector filteredValues; - RigCurveDataTools::getValuesByIntervals(m_xValues, m_intervalsOfContinousValidValues, &filteredValues); + RiaCurveDataTools::getValuesByIntervals(m_xValues, m_intervalsOfContinousValidValues, &filteredValues); return filteredValues; } @@ -133,12 +133,12 @@ std::vector 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 convertedValues = convertDepthValues(destinationDepthUnit, m_tvDepths); - RigCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues); + RiaCurveDataTools::getValuesByIntervals(convertedValues, m_intervalsOfContinousValidValues, &filteredValues); } } @@ -154,12 +154,12 @@ std::vector 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 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 RigWellLogCurveData::measuredDepthPlotValues(RiaDefines::Dep //-------------------------------------------------------------------------------------------------- std::vector> RigWellLogCurveData::polylineStartStopIndices() const { - return RigCurveDataTools::computePolyLineStartStopIndices(m_intervalsOfContinousValidValues); + return RiaCurveDataTools::computePolyLineStartStopIndices(m_intervalsOfContinousValidValues); } //-------------------------------------------------------------------------------------------------- @@ -246,7 +246,7 @@ cvf::ref RigWellLogCurveData::calculateResampledCurveData(d //-------------------------------------------------------------------------------------------------- void RigWellLogCurveData::calculateIntervalsOfContinousValidValues() { - std::vector> intervalsOfValidValues = RigCurveDataTools::calculateIntervalsOfValidValues(m_xValues, false); + std::vector> intervalsOfValidValues = RiaCurveDataTools::calculateIntervalsOfValidValues(m_xValues, false); m_intervalsOfContinousValidValues.clear(); diff --git a/ApplicationCode/UnitTests/RigTimeCurveHistoryMerger-Test.cpp b/ApplicationCode/UnitTests/RigTimeCurveHistoryMerger-Test.cpp index 3754a87b1c..922e8937d9 100644 --- a/ApplicationCode/UnitTests/RigTimeCurveHistoryMerger-Test.cpp +++ b/ApplicationCode/UnitTests/RigTimeCurveHistoryMerger-Test.cpp @@ -1,37 +1,37 @@ #include "gtest/gtest.h" -#include "RigTimeHistoryCurveMerger.h" +#include "RiaTimeHistoryCurveMerger.h" #include // Needed for HUGE_VAL on Linux //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -TEST(RigTimeHistoryCurveMergerTest, TestDateInterpolation) +TEST(RiaTimeHistoryCurveMergerTest, TestDateInterpolation) { std::vector values{ 2.0, 3.5, 5.0, 6.0}; std::vector 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 valuesA { HUGE_VAL, 1.0, HUGE_VAL, 2.0, 2.5, 3.0, 4.0, 5.0, 6.0, HUGE_VAL }; std::vector 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 valuesA { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 }; std::vector 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 valuesA{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 }; std::vector 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 valuesA{ 1, 2, 3, 4, 5 }; std::vector valuesB{ 10, 20, 30, 40, 50 }; @@ -134,7 +134,7 @@ TEST(RigTimeHistoryCurveMergerTest, OverlappintTimes) std::vector timeStepsA{ 0, 10, 11, 15, 20 }; std::vector 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(curveMerger.allTimeSteps().size())); } @@ -164,7 +164,7 @@ TEST(RigTimeHistoryCurveMergerTest, RobustUse) std::vector 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 valuesA{ 1, 2, 3, 4, 5 }; std::vector valuesB{ 10, 20, 30 }; @@ -197,7 +197,7 @@ TEST(RigTimeHistoryCurveMergerTest, NoTimeStepOverlap) std::vector timeStepsB{ 100, 200, 300 }; { - RigTimeHistoryCurveMerger curveMerger; + RiaTimeHistoryCurveMerger curveMerger; curveMerger.addCurveData(valuesA, timeStepsA); curveMerger.addCurveData(valuesB, timeStepsB); diff --git a/ApplicationCode/UnitTests/RimWellLogExtractionCurveImpl-Test.cpp b/ApplicationCode/UnitTests/RimWellLogExtractionCurveImpl-Test.cpp index 9f3d65ccc1..9368b14054 100644 --- a/ApplicationCode/UnitTests/RimWellLogExtractionCurveImpl-Test.cpp +++ b/ApplicationCode/UnitTests/RimWellLogExtractionCurveImpl-Test.cpp @@ -1,6 +1,6 @@ #include "gtest/gtest.h" -#include "RigCurveDataTools.h" +#include "RiaCurveDataTools.h" #include // Needed for HUGE_VAL on Linux #include @@ -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(valuesIntervals.size())); EXPECT_EQ(2, static_cast(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(valuesIntervals.size())); EXPECT_EQ(2, static_cast(valuesIntervals[0].first)); diff --git a/ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.cpp b/ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.cpp index 44f5446e33..b940caca80 100644 --- a/ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.cpp +++ b/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 filteredYErrorValues; { - auto intervalsOfValidValues = RigCurveDataTools::calculateIntervalsOfValidValues(yValues, keepOnlyPositiveValues); + auto intervalsOfValidValues = RiaCurveDataTools::calculateIntervalsOfValidValues(yValues, keepOnlyPositiveValues); - RigCurveDataTools::getValuesByIntervals(yValues, intervalsOfValidValues, &filteredYValues); - RigCurveDataTools::getValuesByIntervals(xValues, intervalsOfValidValues, &filteredXValues); + RiaCurveDataTools::getValuesByIntervals(yValues, intervalsOfValidValues, &filteredYValues); + 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(filteredXValues.size())); diff --git a/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp b/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp index 48a35fb816..c8e4f2c148 100644 --- a/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp +++ b/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) { diff --git a/ApplicationCode/UserInterface/RiuResultQwtPlot.cpp b/ApplicationCode/UserInterface/RiuResultQwtPlot.cpp index bcb625f6d1..d42c4ee627 100644 --- a/ApplicationCode/UserInterface/RiuResultQwtPlot.cpp +++ b/ApplicationCode/UserInterface/RiuResultQwtPlot.cpp @@ -19,7 +19,7 @@ #include "RiuResultQwtPlot.h" -#include "RigCurveDataTools.h" +#include "RiaCurveDataTools.h" #include "RimContextCommandBuilder.h" #include "RimCase.h"