OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

(#561) Moved static methods to separate file

Browse Source
This commit is contained in:
Magne Sjaastad 2015-10-05 13:29:30 +02:00
parent 718f6f9687
commit f4cfc51de2
5 changed files with 198 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/ProjectDataModel/CMakeLists_files.cmake
View File

@ -68,6 +68,7 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.h
${CEE_CURRENT_LIST_DIR}RimViewLinker.h ${CEE_CURRENT_LIST_DIR}RimViewLinker.h
${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.h ${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.h
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.h ${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.h
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurveImpl.h
${CEE_CURRENT_LIST_DIR}RimWellLogFile.h ${CEE_CURRENT_LIST_DIR}RimWellLogFile.h
${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.h ${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.h
${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.h ${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.h
@ -137,6 +138,7 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.cpp
${CEE_CURRENT_LIST_DIR}RimViewLinker.cpp ${CEE_CURRENT_LIST_DIR}RimViewLinker.cpp
${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.cpp ${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.cpp
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.cpp ${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.cpp
${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurveImpl.cpp
${CEE_CURRENT_LIST_DIR}RimWellLogFile.cpp ${CEE_CURRENT_LIST_DIR}RimWellLogFile.cpp
${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.cpp ${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.cpp
${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.cpp ${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.cpp

141
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -18,6 +18,7 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#include "RimWellLogExtractionCurve.h" #include "RimWellLogExtractionCurve.h"
#include "RimWellLogExtractionCurveImpl.h"
#include "RiaApplication.h" #include "RiaApplication.h"
@ -224,9 +225,9 @@ void RimWellLogExtractionCurve::updatePlotData()
if (values.size() > 0 && values.size() == depthValues.size()) if (values.size() > 0 && values.size() == depthValues.size())
{ {
validCurvePointIntervals(depthValues, values, plotIntervals); RimWellLogExtractionCurveImpl::validCurvePointIntervals(depthValues, values, plotIntervals);
addValuesFromIntervals(depthValues, plotIntervals, &filteredDepths); RimWellLogExtractionCurveImpl::addValuesFromIntervals(depthValues, plotIntervals, &filteredDepths);
addValuesFromIntervals(values, plotIntervals, &filteredValues); RimWellLogExtractionCurveImpl::addValuesFromIntervals(values, plotIntervals, &filteredValues);
} }
} }
else if (geomExtractor.notNull()) // geomExtractor else if (geomExtractor.notNull()) // geomExtractor
@ -238,16 +239,16 @@ void RimWellLogExtractionCurve::updatePlotData()
if (values.size() > 0 && values.size() == depthValues.size()) if (values.size() > 0 && values.size() == depthValues.size())
{ {
validCurvePointIntervals(depthValues, values, plotIntervals); RimWellLogExtractionCurveImpl::validCurvePointIntervals(depthValues, values, plotIntervals);
addValuesFromIntervals(depthValues, plotIntervals, &filteredDepths); RimWellLogExtractionCurveImpl::addValuesFromIntervals(depthValues, plotIntervals, &filteredDepths);
addValuesFromIntervals(values, plotIntervals, &filteredValues); RimWellLogExtractionCurveImpl::addValuesFromIntervals(values, plotIntervals, &filteredValues);
} }
} }
m_plotCurve->setSamples(filteredValues.data(), filteredDepths.data(), (int)filteredValues.size()); m_plotCurve->setSamples(filteredValues.data(), filteredDepths.data(), (int)filteredValues.size());
std::vector< std::pair<size_t, size_t> > fltrIntervals; std::vector< std::pair<size_t, size_t> > fltrIntervals;
filteredIntervals(plotIntervals, &fltrIntervals); RimWellLogExtractionCurveImpl::filteredIntervals(plotIntervals, &fltrIntervals);
m_plotCurve->setPlotIntervals(fltrIntervals); m_plotCurve->setPlotIntervals(fltrIntervals);
@ -393,132 +394,6 @@ void RimWellLogExtractionCurve::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiT
uiTreeOrdering.setForgetRemainingFields(true); uiTreeOrdering.setForgetRemainingFields(true);
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogExtractionCurve::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;
validValuesIntervals(values, valuesIntervals);
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 RimWellLogExtractionCurve::validValuesIntervals(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 < valueCount)
{
intervals.push_back(std::make_pair(startIdx, valueCount - 1));
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogExtractionCurve::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 (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 RimWellLogExtractionCurve::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 RimWellLogExtractionCurve::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;
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///

7
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h
View File

@ -69,13 +69,6 @@ protected:
caf::PdmField<bool> m_addWellNameToCurveName; caf::PdmField<bool> m_addWellNameToCurveName;
caf::PdmField<bool> m_addTimestepToCurveName; caf::PdmField<bool> m_addTimestepToCurveName;
caf::PdmField<bool> m_addDateToCurveName; caf::PdmField<bool> m_addDateToCurveName;
private:
static void validValuesIntervals(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);
}; };

149
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurveImpl.cpp Normal file
View File

@ -0,0 +1,149 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "RimWellLogExtractionCurveImpl.h"
#include "cvfAssert.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogExtractionCurveImpl::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;
validValuesIntervals(values, valuesIntervals);
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 RimWellLogExtractionCurveImpl::validValuesIntervals(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 < valueCount)
{
intervals.push_back(std::make_pair(startIdx, valueCount - 1));
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogExtractionCurveImpl::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 (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 RimWellLogExtractionCurveImpl::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 RimWellLogExtractionCurveImpl::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;
}
}

39
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurveImpl.h Normal file
View File

@ -0,0 +1,39 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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>
//==================================================================================================
///
///
//==================================================================================================
class RimWellLogExtractionCurveImpl
{
public:
static void validValuesIntervals(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);
};