Move RigCurveDataTools and RigTimeHistoryCurveMerger to Application/Tools plus rename

This commit is contained in:
Bjørn Erik Jensen 2018-06-08 15:10:45 +02:00
parent 68f965f6bb
commit eebd8bef2d
19 changed files with 528 additions and 64 deletions

View File

@ -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

View File

@ -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;
}

View File

@ -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);
};

View File

@ -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;
}

View File

@ -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;
};

View File

@ -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];

View File

@ -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);

View File

@ -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++)
{

View File

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

View File

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

View File

@ -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();
{

View File

@ -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();

View File

@ -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

View File

@ -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();

View File

@ -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);

View File

@ -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));

View File

@ -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);
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<int>(filteredXValues.size()));

View File

@ -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)
{

View File

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