mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Moved remaining code from RimWellLogCurveImpl to RigWellLogCurveData
Removed class RimWellLogCurveImpl. RigWellLogCurveData::calculateValidPointsIntervals() needs to be harmonized with new way of extracting depths from well paths.
This commit is contained in:
Pål Hagen
parent
c2577391c2
commit
956beba118
@ -68,7 +68,6 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.h
|
||||
${CEE_CURRENT_LIST_DIR}RimViewLinker.h
|
||||
${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.h
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.h
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogCurveImpl.h
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFile.h
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.h
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.h
|
||||
@ -138,7 +137,6 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimViewLinker.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogCurveImpl.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFile.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.cpp
|
||||
${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.cpp
|
||||
|
||||
@ -1,162 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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 "RimWellLogCurveImpl.h"
|
||||
|
||||
#include "cvfBase.h"
|
||||
#include "cvfMath.h"
|
||||
#include "cvfAssert.h"
|
||||
|
||||
#include <cmath> // Needed for HUGE_VAL on Linux
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RimWellLogCurveImpl::validCurvePointIntervals(const std::vector<double>& depthValues, const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals)
|
||||
{
|
||||
std::vector< std::pair<size_t, size_t> > valuesIntervals;
|
||||
calculateIntervalsOfValidValues(values, valuesIntervals);
|
||||
|
||||
intervals = valuesIntervals;
|
||||
|
||||
// TODO: The following code does not work as expected
|
||||
// See issue #459 (original issue) and bugs #557 #560 and #561
|
||||
// Suggestion: Remove code related to filtering out depth values,
|
||||
// because we want to see the value difference at element borders
|
||||
|
||||
/*
|
||||
size_t intervalsCount = valuesIntervals.size();
|
||||
for (size_t intIdx = 0; intIdx < intervalsCount; intIdx++)
|
||||
{
|
||||
std::vector< std::pair<size_t, size_t> > depthValuesIntervals;
|
||||
validDepthValuesIntervals(depthValues, valuesIntervals[intIdx].first, valuesIntervals[intIdx].second, depthValuesIntervals);
|
||||
|
||||
for (size_t dvintIdx = 0; dvintIdx < depthValuesIntervals.size(); dvintIdx++)
|
||||
{
|
||||
intervals.push_back(depthValuesIntervals[dvintIdx]);
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RimWellLogCurveImpl::calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals)
|
||||
{
|
||||
int startIdx = -1;
|
||||
size_t vIdx = 0;
|
||||
|
||||
size_t valueCount = values.size();
|
||||
while (vIdx < valueCount)
|
||||
{
|
||||
double value = values[vIdx];
|
||||
if (value == HUGE_VAL || value == -HUGE_VAL || value != value)
|
||||
{
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RimWellLogCurveImpl::validDepthValuesIntervals(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >& intervals)
|
||||
{
|
||||
if (startIdx > stopIdx)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (startIdx == stopIdx || stopIdx - startIdx == 1)
|
||||
{
|
||||
intervals.push_back(std::make_pair(startIdx, stopIdx));
|
||||
return;
|
||||
}
|
||||
|
||||
// !! TODO: Find a reasonable tolerance
|
||||
const double depthDiffTolerance = 0.1;
|
||||
|
||||
// Find intervals containing depth values that should be connected
|
||||
size_t intStartIdx = startIdx;
|
||||
for (size_t vIdx = startIdx + 1; vIdx < stopIdx; vIdx += 2)
|
||||
{
|
||||
if (cvf::Math::abs(depthValues[vIdx + 1] - depthValues[vIdx]) > depthDiffTolerance)
|
||||
{
|
||||
intervals.push_back(std::make_pair(intStartIdx, vIdx));
|
||||
intStartIdx = vIdx + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (intStartIdx <= stopIdx)
|
||||
{
|
||||
intervals.push_back(std::make_pair(intStartIdx, stopIdx));
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RimWellLogCurveImpl::addValuesFromIntervals(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* 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]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RimWellLogCurveImpl::filteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* fltrIntervals)
|
||||
{
|
||||
CVF_ASSERT(fltrIntervals);
|
||||
|
||||
const size_t intervalCount = intervals.size();
|
||||
if (intervalCount < 1) return;
|
||||
|
||||
size_t index = 0;
|
||||
for (size_t intIdx = 0; intIdx < intervalCount; intIdx++)
|
||||
{
|
||||
size_t intervalSize = intervals[intIdx].second - intervals[intIdx].first + 1;
|
||||
fltrIntervals->push_back(std::make_pair(index, index + intervalSize - 1));
|
||||
|
||||
index += intervalSize;
|
||||
}
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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 <vector>
|
||||
#include <cstddef>
|
||||
|
||||
|
||||
//==================================================================================================
|
||||
///
|
||||
///
|
||||
//==================================================================================================
|
||||
class RimWellLogCurveImpl
|
||||
{
|
||||
public:
|
||||
static void calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals);
|
||||
static void validDepthValuesIntervals(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >& intervals);
|
||||
static void validCurvePointIntervals(const std::vector<double>& depthValues, const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals);
|
||||
static void addValuesFromIntervals(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
|
||||
static void filteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* fltrIntervals);
|
||||
};
|
||||
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "RimWellLogExtractionCurve.h"
|
||||
#include "RimWellLogCurveImpl.h"
|
||||
|
||||
#include "RiaApplication.h"
|
||||
|
||||
|
||||
@ -27,7 +27,6 @@
|
||||
#include "RimWellLogFile.h"
|
||||
#include "RimWellLogPlotTrack.h"
|
||||
#include "RimWellLogPlot.h"
|
||||
#include "RimWellLogCurveImpl.h"
|
||||
|
||||
#include "RiuWellLogTrackPlot.h"
|
||||
#include "RiuWellLogPlotCurve.h"
|
||||
|
||||
@ -19,6 +19,9 @@
|
||||
|
||||
#include "RigWellLogCurveData.h"
|
||||
|
||||
#include "cvfMath.h"
|
||||
#include "cvfAssert.h"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -45,7 +48,7 @@ void RigWellLogCurveData::setPoints(const std::vector<double>& xValues, const st
|
||||
m_xValues = xValues;
|
||||
m_yValues = yValues;
|
||||
|
||||
calculateValidXValuesIntervals();
|
||||
calculateValidPointsIntervals();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -69,7 +72,7 @@ const std::vector<double>& RigWellLogCurveData::yValues() const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const std::vector< std::pair<size_t, size_t> >& RigWellLogCurveData::filteredIntervals() const
|
||||
{
|
||||
return m_validXValuesIntervals;
|
||||
return m_validPointsIntervals;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -78,7 +81,7 @@ const std::vector< std::pair<size_t, size_t> >& RigWellLogCurveData::filteredInt
|
||||
std::vector<double> RigWellLogCurveData::validXValues() const
|
||||
{
|
||||
std::vector<double> filteredValues;
|
||||
pickValuesFromIntervals(m_xValues, m_validXValuesIntervals, &filteredValues);
|
||||
getValuesByIntervals(m_xValues, m_validPointsIntervals, &filteredValues);
|
||||
|
||||
return filteredValues;
|
||||
}
|
||||
@ -89,7 +92,7 @@ std::vector<double> RigWellLogCurveData::validXValues() const
|
||||
std::vector<double> RigWellLogCurveData::validYValues() const
|
||||
{
|
||||
std::vector<double> filteredValues;
|
||||
pickValuesFromIntervals(m_yValues, m_validXValuesIntervals, &filteredValues);
|
||||
getValuesByIntervals(m_yValues, m_validPointsIntervals, &filteredValues);
|
||||
|
||||
return filteredValues;
|
||||
}
|
||||
@ -100,7 +103,7 @@ std::vector<double> RigWellLogCurveData::validYValues() const
|
||||
std::vector< std::pair<size_t, size_t> > RigWellLogCurveData::validPointsIntervals() const
|
||||
{
|
||||
std::vector< std::pair<size_t, size_t> > intervals;
|
||||
computeFilteredIntervals(m_validXValuesIntervals, &intervals);
|
||||
computeFilteredIntervals(m_validPointsIntervals, &intervals);
|
||||
|
||||
return intervals;
|
||||
}
|
||||
@ -109,9 +112,26 @@ std::vector< std::pair<size_t, size_t> > RigWellLogCurveData::validPointsInterva
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::calculateValidXValuesIntervals()
|
||||
void RigWellLogCurveData::calculateValidPointsIntervals()
|
||||
{
|
||||
calculateIntervalsOfValidValues(m_xValues, &m_validXValuesIntervals);
|
||||
std::vector< std::pair<size_t, size_t> > valuesIntervals;
|
||||
calculateIntervalsOfValidValues(m_xValues, &valuesIntervals);
|
||||
|
||||
std::vector< std::pair<size_t, size_t> > pointsIntervals;
|
||||
|
||||
size_t intervalsCount = valuesIntervals.size();
|
||||
for (size_t intIdx = 0; intIdx < intervalsCount; intIdx++)
|
||||
{
|
||||
std::vector< std::pair<size_t, size_t> > depthValuesIntervals;
|
||||
calculateIntervalsOfValidDepthValues(m_yValues, valuesIntervals[intIdx].first, valuesIntervals[intIdx].second, &depthValuesIntervals);
|
||||
|
||||
for (size_t dvintIdx = 0; dvintIdx < depthValuesIntervals.size(); dvintIdx++)
|
||||
{
|
||||
pointsIntervals.push_back(depthValuesIntervals[dvintIdx]);
|
||||
}
|
||||
}
|
||||
|
||||
m_validPointsIntervals = pointsIntervals;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -150,11 +170,49 @@ void RigWellLogCurveData::calculateIntervalsOfValidValues(const std::vector<doub
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::calculateIntervalsOfValidDepthValues(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >* intervals)
|
||||
{
|
||||
CVF_ASSERT(intervals);
|
||||
|
||||
if (startIdx > stopIdx)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (startIdx == stopIdx || stopIdx - startIdx == 1)
|
||||
{
|
||||
intervals->push_back(std::make_pair(startIdx, stopIdx));
|
||||
return;
|
||||
}
|
||||
|
||||
// !! TODO: Find a reasonable tolerance
|
||||
const double depthDiffTolerance = 0.1;
|
||||
|
||||
// Find intervals containing depth values that should be connected
|
||||
size_t intStartIdx = startIdx;
|
||||
for (size_t vIdx = startIdx + 1; vIdx < stopIdx; vIdx += 2)
|
||||
{
|
||||
if (cvf::Math::abs(depthValues[vIdx + 1] - depthValues[vIdx]) > depthDiffTolerance)
|
||||
{
|
||||
intervals->push_back(std::make_pair(intStartIdx, vIdx));
|
||||
intStartIdx = vIdx + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (intStartIdx <= stopIdx)
|
||||
{
|
||||
intervals->push_back(std::make_pair(intStartIdx, stopIdx));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::pickValuesFromIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues)
|
||||
void RigWellLogCurveData::getValuesByIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues)
|
||||
{
|
||||
CVF_ASSERT(filteredValues);
|
||||
|
||||
|
||||
@ -46,16 +46,17 @@ public:
|
||||
std::vector< std::pair<size_t, size_t> > validPointsIntervals() const;
|
||||
|
||||
private:
|
||||
void calculateValidXValuesIntervals();
|
||||
void calculateValidPointsIntervals();
|
||||
|
||||
static void calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >* intervals);
|
||||
static void pickValuesFromIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
|
||||
static void calculateIntervalsOfValidDepthValues(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >* intervals);
|
||||
static void getValuesByIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
|
||||
static void computeFilteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* filteredIntervals);
|
||||
|
||||
private:
|
||||
std::vector<double> m_xValues;
|
||||
std::vector<double> m_yValues;
|
||||
std::vector< std::pair<size_t, size_t> > m_validXValuesIntervals;
|
||||
std::vector< std::pair<size_t, size_t> > m_validPointsIntervals;
|
||||
|
||||
friend class RigWellLogCurveDataTestInterface;
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user