mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Move Rig well related things to subfolder and update include statements
This commit is contained in:
jonjenssen
jonjenssen
@@ -0,0 +1,675 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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 "RigWellLogCurveData.h"
|
||||
|
||||
#include "RiaCurveDataTools.h"
|
||||
#include "RiaWellLogUnitTools.h"
|
||||
|
||||
#include "cvfAssert.h"
|
||||
#include "cvfMath.h"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigWellLogCurveData::RigWellLogCurveData()
|
||||
: m_isExtractionCurve( false )
|
||||
, m_rkbDiff( 0.0 )
|
||||
, m_useLogarithmicScale( false )
|
||||
, m_depthUnit( RiaDefines::DepthUnitType::UNIT_METER )
|
||||
, m_propertyValueUnitString( RiaWellLogUnitTools<double>::noUnitString() )
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigWellLogCurveData::~RigWellLogCurveData()
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::clear()
|
||||
{
|
||||
m_propertyValues.clear();
|
||||
m_depths.clear();
|
||||
m_intervalsOfContinousValidValues.clear();
|
||||
m_propertyValueUnitString.clear();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::setDepthUnit( RiaDefines::DepthUnitType depthUnit )
|
||||
{
|
||||
m_depthUnit = depthUnit;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::setValuesAndDepths( const std::vector<double>& xValues,
|
||||
const std::vector<double>& depths,
|
||||
RiaDefines::DepthTypeEnum depthType,
|
||||
double rkbDiff,
|
||||
RiaDefines::DepthUnitType depthUnit,
|
||||
bool isExtractionCurve,
|
||||
bool useLogarithmicScale )
|
||||
{
|
||||
CVF_ASSERT( xValues.size() == depths.size() );
|
||||
|
||||
m_propertyValues = xValues;
|
||||
m_depths[depthType] = depths;
|
||||
m_depthUnit = depthUnit;
|
||||
m_rkbDiff = rkbDiff;
|
||||
m_useLogarithmicScale = useLogarithmicScale;
|
||||
|
||||
// Disable depth value filtering is intended to be used for
|
||||
// extraction curve data
|
||||
m_isExtractionCurve = isExtractionCurve;
|
||||
|
||||
calculateIntervalsOfContinousValidValues();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::setValuesAndDepths( const std::vector<double>& xValues,
|
||||
const std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& depths,
|
||||
double rkbDiff,
|
||||
RiaDefines::DepthUnitType depthUnit,
|
||||
bool isExtractionCurve,
|
||||
bool useLogarithmicScale )
|
||||
{
|
||||
for ( auto it = depths.begin(); it != depths.end(); ++it )
|
||||
{
|
||||
CVF_ASSERT( xValues.size() == it->second.size() );
|
||||
}
|
||||
|
||||
m_propertyValues = xValues;
|
||||
m_depths = depths;
|
||||
m_depthUnit = depthUnit;
|
||||
m_rkbDiff = rkbDiff;
|
||||
m_useLogarithmicScale = useLogarithmicScale;
|
||||
|
||||
// Disable depth value filtering is intended to be used for
|
||||
// extraction curve data
|
||||
m_isExtractionCurve = isExtractionCurve;
|
||||
|
||||
calculateIntervalsOfContinousValidValues();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::setPropertyValueUnit( const QString& propertyValueUnitString )
|
||||
{
|
||||
m_propertyValueUnitString = propertyValueUnitString;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::propertyValues() const
|
||||
{
|
||||
return m_propertyValues;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::propertyValues( const QString& units ) const
|
||||
{
|
||||
std::vector<double> convertedValues;
|
||||
if ( units != m_propertyValueUnitString &&
|
||||
RiaWellLogUnitTools<double>::convertValues( depths( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB ),
|
||||
m_propertyValues,
|
||||
&convertedValues,
|
||||
m_propertyValueUnitString,
|
||||
units ) )
|
||||
{
|
||||
return convertedValues;
|
||||
}
|
||||
return m_propertyValues;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QString RigWellLogCurveData::propertyValueUnit() const
|
||||
{
|
||||
return m_propertyValueUnitString;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::depths( RiaDefines::DepthTypeEnum depthType ) const
|
||||
{
|
||||
auto it = m_depths.find( depthType );
|
||||
if ( it != m_depths.end() )
|
||||
{
|
||||
return it->second;
|
||||
}
|
||||
|
||||
if ( depthType == RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB && m_depths.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH ) )
|
||||
{
|
||||
std::vector<double> tvds = depths( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH );
|
||||
for ( double& tvdValue : tvds )
|
||||
{
|
||||
tvdValue += m_rkbDiff;
|
||||
}
|
||||
return tvds;
|
||||
}
|
||||
else if ( depthType == RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH &&
|
||||
m_depths.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB ) )
|
||||
{
|
||||
std::vector<double> tvds = depths( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB );
|
||||
for ( double& tvdValue : tvds )
|
||||
{
|
||||
tvdValue -= m_rkbDiff;
|
||||
}
|
||||
return tvds;
|
||||
}
|
||||
|
||||
return std::vector<double>();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::depths( RiaDefines::DepthTypeEnum depthType, RiaDefines::DepthUnitType destinationDepthUnit ) const
|
||||
{
|
||||
return depthsForDepthUnit( depths( depthType ), m_depthUnit, destinationDepthUnit );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::set<RiaDefines::DepthTypeEnum> RigWellLogCurveData::availableDepthTypes() const
|
||||
{
|
||||
std::set<RiaDefines::DepthTypeEnum> depthTypes;
|
||||
|
||||
for ( auto depthValuePair : m_depths )
|
||||
{
|
||||
depthTypes.insert( depthValuePair.first );
|
||||
}
|
||||
|
||||
if ( m_rkbDiff != 0.0 )
|
||||
{
|
||||
if ( depthTypes.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH ) &&
|
||||
!depthTypes.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB ) )
|
||||
{
|
||||
depthTypes.insert( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB );
|
||||
}
|
||||
else if ( depthTypes.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB ) &&
|
||||
!depthTypes.count( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH ) )
|
||||
{
|
||||
depthTypes.insert( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH );
|
||||
}
|
||||
}
|
||||
|
||||
return depthTypes;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::propertyValuesByIntervals() const
|
||||
{
|
||||
std::vector<double> filteredValues;
|
||||
RiaCurveDataTools::getValuesByIntervals( m_propertyValues, m_intervalsOfContinousValidValues, &filteredValues );
|
||||
|
||||
return filteredValues;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::depthValuesByIntervals( RiaDefines::DepthTypeEnum depthType,
|
||||
RiaDefines::DepthUnitType destinationDepthUnit ) const
|
||||
{
|
||||
const std::vector<double> depthValues = RigWellLogCurveData::depthsForDepthUnit( depths( depthType ), m_depthUnit, destinationDepthUnit );
|
||||
if ( depthValues.empty() ) return depthValues;
|
||||
|
||||
std::vector<double> filteredValues;
|
||||
RiaCurveDataTools::getValuesByIntervals( depthValues, m_intervalsOfContinousValidValues, &filteredValues );
|
||||
|
||||
return filteredValues;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<std::pair<size_t, size_t>> RigWellLogCurveData::polylineStartStopIndices() const
|
||||
{
|
||||
return RiaCurveDataTools::computePolyLineStartStopIndices( m_intervalsOfContinousValidValues );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<RigWellLogCurveData> RigWellLogCurveData::calculateResampledCurveData( double newMeasuredDepthStepSize ) const
|
||||
{
|
||||
std::vector<double> xValues;
|
||||
std::vector<double> measuredDepths;
|
||||
|
||||
bool isTVDAvailable = false;
|
||||
std::vector<double> tvDepths;
|
||||
|
||||
auto mdIt = m_depths.find( RiaDefines::DepthTypeEnum::MEASURED_DEPTH );
|
||||
auto tvdIt = m_depths.find( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH );
|
||||
|
||||
if ( tvdIt != m_depths.end() && !tvdIt->second.empty() ) isTVDAvailable = true;
|
||||
|
||||
if ( mdIt != m_depths.end() && !mdIt->second.empty() )
|
||||
{
|
||||
double currentMd = mdIt->second.front();
|
||||
|
||||
size_t segmentStartIdx = 0;
|
||||
while ( segmentStartIdx < mdIt->second.size() - 1 )
|
||||
{
|
||||
double segmentStartMd = mdIt->second[segmentStartIdx];
|
||||
double segmentEndMd = mdIt->second[segmentStartIdx + 1];
|
||||
double segmentStartX = m_propertyValues[segmentStartIdx];
|
||||
double segmentEndX = m_propertyValues[segmentStartIdx + 1];
|
||||
|
||||
double segmentStartTvd = 0.0;
|
||||
double segmentEndTvd = 0.0;
|
||||
if ( isTVDAvailable )
|
||||
{
|
||||
segmentStartTvd = tvdIt->second[segmentStartIdx];
|
||||
segmentEndTvd = tvdIt->second[segmentStartIdx + 1];
|
||||
}
|
||||
|
||||
while ( currentMd <= segmentEndMd )
|
||||
{
|
||||
measuredDepths.push_back( currentMd );
|
||||
double endWeight = ( currentMd - segmentStartMd ) / ( segmentEndMd - segmentStartMd );
|
||||
xValues.push_back( ( 1.0 - endWeight ) * segmentStartX + endWeight * segmentEndX );
|
||||
|
||||
// The tvd calculation is a simplification. We should use the wellpath, as it might have a better
|
||||
// resolution, and have a none-linear shape This is much simpler, and possibly accurate enough ?
|
||||
|
||||
if ( isTVDAvailable )
|
||||
{
|
||||
tvDepths.push_back( ( 1.0 - endWeight ) * segmentStartTvd + endWeight * segmentEndTvd );
|
||||
}
|
||||
|
||||
currentMd += newMeasuredDepthStepSize;
|
||||
}
|
||||
|
||||
segmentStartIdx++;
|
||||
}
|
||||
}
|
||||
|
||||
cvf::ref<RigWellLogCurveData> reSampledData = new RigWellLogCurveData;
|
||||
|
||||
if ( isTVDAvailable )
|
||||
{
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>> resampledDepths =
|
||||
{ { RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH, tvDepths }, { RiaDefines::DepthTypeEnum::MEASURED_DEPTH, measuredDepths } };
|
||||
reSampledData->setValuesAndDepths( xValues, resampledDepths, m_rkbDiff, m_depthUnit, true, m_useLogarithmicScale );
|
||||
}
|
||||
else
|
||||
{
|
||||
reSampledData->setValuesAndDepths( xValues,
|
||||
measuredDepths,
|
||||
RiaDefines::DepthTypeEnum::MEASURED_DEPTH,
|
||||
0.0,
|
||||
m_depthUnit,
|
||||
m_isExtractionCurve,
|
||||
m_useLogarithmicScale );
|
||||
}
|
||||
|
||||
return reSampledData;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// The function creates and adds interpolated values for property and depths. The interpolated
|
||||
/// values are added to the end of the resampledValues. Target depth is added to the end of the
|
||||
/// resampledDepths vector for the resampling type. The depth values for remaining depth types
|
||||
/// are created by linear interpolation between first and second depth value of the resampling type.
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::createAndAddInterpolatedSegmentValueAndDepths(
|
||||
std::vector<double>& resampledValues,
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& resampledDepths,
|
||||
RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
double targetDepthValue,
|
||||
size_t firstIndex,
|
||||
size_t secondIndex,
|
||||
const std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& originalDepths,
|
||||
const std::vector<double>& propertyValues,
|
||||
double eps )
|
||||
{
|
||||
if ( !originalDepths.contains( resamplingDepthType ) ) return;
|
||||
|
||||
const auto& depthValues = originalDepths.find( resamplingDepthType )->second;
|
||||
if ( firstIndex >= depthValues.size() || secondIndex >= depthValues.size() ) return;
|
||||
|
||||
double depth0 = depthValues[firstIndex];
|
||||
double depth1 = depthValues[secondIndex];
|
||||
double x0 = propertyValues[firstIndex];
|
||||
double x1 = propertyValues[secondIndex];
|
||||
double slope = 0.0;
|
||||
if ( std::fabs( depth1 - depth0 ) > eps )
|
||||
{
|
||||
slope = ( x1 - x0 ) / ( depth1 - depth0 );
|
||||
}
|
||||
double resampledValue = slope * ( targetDepthValue - depth0 ) + x0;
|
||||
resampledValues.push_back( resampledValue );
|
||||
resampledDepths[resamplingDepthType].push_back( targetDepthValue );
|
||||
|
||||
// Add depth values for remaining depth types
|
||||
for ( const auto& [depthType, depthTypeValues] : originalDepths )
|
||||
{
|
||||
if ( depthType == resamplingDepthType ) continue;
|
||||
if ( firstIndex >= depthTypeValues.size() || secondIndex >= depthTypeValues.size() ) continue;
|
||||
|
||||
double otherDepth0 = depthTypeValues[firstIndex];
|
||||
double otherDepth1 = depthTypeValues[secondIndex];
|
||||
double otherSlope = ( otherDepth1 - otherDepth0 ) / ( depth1 - depth0 );
|
||||
resampledDepths[depthType].push_back( otherSlope * ( targetDepthValue - depth0 ) + otherDepth0 );
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool isLeftOf( double x1, double x2, bool reverseOrder, double eps )
|
||||
{
|
||||
if ( reverseOrder )
|
||||
{
|
||||
return x1 - x2 > eps;
|
||||
}
|
||||
return x2 - x1 > eps;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool isRightOf( double x1, double x2, bool reverseOrder, double eps )
|
||||
{
|
||||
return isLeftOf( x2, x1, reverseOrder, eps );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::pair<std::vector<double>, std::map<RiaDefines::DepthTypeEnum, std::vector<double>>>
|
||||
RigWellLogCurveData::createResampledValuesAndDepths( RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
const std::vector<double>& targetDepths,
|
||||
const std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& originalDepths,
|
||||
const std::vector<double>& propertyValues )
|
||||
{
|
||||
const double eps = 1.0e-8;
|
||||
|
||||
auto depthIt = originalDepths.find( resamplingDepthType );
|
||||
if ( depthIt == originalDepths.end() || depthIt->second.empty() ) return {};
|
||||
const auto& depthValues = depthIt->second;
|
||||
|
||||
bool reverseOrder = resamplingDepthType == RiaDefines::DepthTypeEnum::CONNECTION_NUMBER;
|
||||
|
||||
std::vector<double> resampledValues;
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>> resampledDepths;
|
||||
|
||||
size_t segmentSearchStartIdx = 0;
|
||||
for ( const auto& targetDepth : targetDepths )
|
||||
{
|
||||
bool foundPoint = false;
|
||||
for ( size_t segmentStartIdx = segmentSearchStartIdx; segmentStartIdx < depthValues.size(); ++segmentStartIdx )
|
||||
{
|
||||
if ( std::fabs( depthValues[segmentStartIdx] - targetDepth ) < eps ) // already have this depth point, reuse it
|
||||
{
|
||||
// Copy all depth data for this segment
|
||||
resampledValues.push_back( propertyValues[segmentStartIdx] );
|
||||
for ( const auto& [depthType, depthValues] : originalDepths )
|
||||
{
|
||||
resampledDepths[depthType].push_back( depthValues[segmentStartIdx] );
|
||||
}
|
||||
segmentSearchStartIdx = segmentStartIdx + 1;
|
||||
foundPoint = true;
|
||||
break;
|
||||
}
|
||||
else if ( segmentStartIdx > 0 && segmentStartIdx < depthValues.size() )
|
||||
{
|
||||
// Interpolate between current and previous depth point
|
||||
const size_t firstIndex = segmentStartIdx - 1;
|
||||
const size_t secondIndex = segmentStartIdx;
|
||||
double minDepthSegment = std::min( depthValues[firstIndex], depthValues[secondIndex] );
|
||||
double maxDepthSegment = std::max( depthValues[firstIndex], depthValues[secondIndex] );
|
||||
if ( cvf::Math::valueInRange( targetDepth, minDepthSegment, maxDepthSegment ) )
|
||||
{
|
||||
createAndAddInterpolatedSegmentValueAndDepths( resampledValues,
|
||||
resampledDepths,
|
||||
resamplingDepthType,
|
||||
targetDepth,
|
||||
firstIndex,
|
||||
secondIndex,
|
||||
originalDepths,
|
||||
propertyValues,
|
||||
eps );
|
||||
segmentSearchStartIdx = segmentStartIdx;
|
||||
foundPoint = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !foundPoint )
|
||||
{
|
||||
if ( isLeftOf( targetDepth, depthValues.front(), reverseOrder, eps ) )
|
||||
{
|
||||
// Extrapolate from front two
|
||||
const size_t firstIndex = 0;
|
||||
const size_t secondIndex = 1;
|
||||
createAndAddInterpolatedSegmentValueAndDepths( resampledValues,
|
||||
resampledDepths,
|
||||
resamplingDepthType,
|
||||
targetDepth,
|
||||
firstIndex,
|
||||
secondIndex,
|
||||
originalDepths,
|
||||
propertyValues,
|
||||
eps );
|
||||
foundPoint = true;
|
||||
}
|
||||
else if ( isRightOf( targetDepth, depthValues.back(), reverseOrder, eps ) )
|
||||
{
|
||||
// Extrapolate from end two
|
||||
const size_t N = depthValues.size() - 1;
|
||||
const size_t N_1 = N - 1;
|
||||
createAndAddInterpolatedSegmentValueAndDepths( resampledValues,
|
||||
resampledDepths,
|
||||
resamplingDepthType,
|
||||
targetDepth,
|
||||
N_1,
|
||||
N,
|
||||
originalDepths,
|
||||
propertyValues,
|
||||
eps );
|
||||
foundPoint = true;
|
||||
}
|
||||
}
|
||||
|
||||
CAF_ASSERT( foundPoint );
|
||||
}
|
||||
|
||||
return std::make_pair( resampledValues, resampledDepths );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<RigWellLogCurveData> RigWellLogCurveData::calculateResampledCurveData( RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
const std::vector<double>& depths ) const
|
||||
{
|
||||
const auto [xValues, resampledDepths] = createResampledValuesAndDepths( resamplingDepthType, depths, m_depths, m_propertyValues );
|
||||
|
||||
cvf::ref<RigWellLogCurveData> reSampledData = new RigWellLogCurveData;
|
||||
reSampledData->setValuesAndDepths( xValues, resampledDepths, m_rkbDiff, m_depthUnit, true, m_useLogarithmicScale );
|
||||
return reSampledData;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::calculateIntervalsOfContinousValidValues()
|
||||
{
|
||||
std::vector<std::pair<size_t, size_t>> intervalsOfValidValues =
|
||||
RiaCurveDataTools::calculateIntervalsOfValidValues( m_propertyValues, m_useLogarithmicScale );
|
||||
|
||||
m_intervalsOfContinousValidValues.clear();
|
||||
|
||||
if ( !m_isExtractionCurve || !m_depths.count( RiaDefines::DepthTypeEnum::MEASURED_DEPTH ) )
|
||||
{
|
||||
m_intervalsOfContinousValidValues = intervalsOfValidValues;
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t intervalsCount = intervalsOfValidValues.size();
|
||||
for ( size_t intIdx = 0; intIdx < intervalsCount; intIdx++ )
|
||||
{
|
||||
std::vector<std::pair<size_t, size_t>> depthValuesIntervals;
|
||||
splitIntervalAtEmptySpace( m_depths[RiaDefines::DepthTypeEnum::MEASURED_DEPTH],
|
||||
intervalsOfValidValues[intIdx].first,
|
||||
intervalsOfValidValues[intIdx].second,
|
||||
&depthValuesIntervals );
|
||||
|
||||
for ( size_t dvintIdx = 0; dvintIdx < depthValuesIntervals.size(); dvintIdx++ )
|
||||
{
|
||||
m_intervalsOfContinousValidValues.push_back( depthValuesIntervals[dvintIdx] );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double> RigWellLogCurveData::depthsForDepthUnit( const std::vector<double>& depths,
|
||||
RiaDefines::DepthUnitType sourceDepthUnit,
|
||||
RiaDefines::DepthUnitType destinationDepthUnit )
|
||||
{
|
||||
if ( destinationDepthUnit == sourceDepthUnit ) return depths;
|
||||
|
||||
std::vector<double> convertedValues = RiaWellLogUnitTools<double>::convertDepths( depths, sourceDepthUnit, destinationDepthUnit );
|
||||
return convertedValues;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Splits the start stop interval between cells that are not close enough.
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::splitIntervalAtEmptySpace( const std::vector<double>& depthValues,
|
||||
size_t startIdx,
|
||||
size_t stopIdx,
|
||||
std::vector<std::pair<size_t, size_t>>* intervals )
|
||||
{
|
||||
CVF_ASSERT( intervals );
|
||||
|
||||
CVF_ASSERT( startIdx <= stopIdx );
|
||||
|
||||
if ( 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:
|
||||
//
|
||||
// vIdx = 0 is the first point of a well, usually outside of the model. Further depth values are
|
||||
// organized in pairs of depths (in and out of a cell), and sometimes the depths varies slightly. If
|
||||
// the distance between a depth pair is larger than the depthDiffTolerance, the two sections will be split
|
||||
// into two intervals.
|
||||
//
|
||||
// The first pair is located at vIdx = 1 & 2. If startIdx = 0, an offset of 1 is added to vIdx, to access
|
||||
// that pair in the loop. If startIdx = 1 (can happen if the start point is inside of the model and invalid),
|
||||
// the offset is not needed.
|
||||
|
||||
size_t intervalStartIdx = startIdx;
|
||||
size_t offset = 1 - startIdx % 2;
|
||||
for ( size_t vIdx = startIdx + offset; vIdx < stopIdx; vIdx += 2 )
|
||||
{
|
||||
if ( cvf::Math::abs( depthValues[vIdx + 1] - depthValues[vIdx] ) > depthDiffTolerance )
|
||||
{
|
||||
intervals->push_back( std::make_pair( intervalStartIdx, vIdx ) );
|
||||
intervalStartIdx = vIdx + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if ( intervalStartIdx <= stopIdx )
|
||||
{
|
||||
intervals->push_back( std::make_pair( intervalStartIdx, stopIdx ) );
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigWellLogCurveData::calculateDepthRange( RiaDefines::DepthTypeEnum depthType,
|
||||
RiaDefines::DepthUnitType depthUnit,
|
||||
double* minimumDepth,
|
||||
double* maximumDepth ) const
|
||||
{
|
||||
CVF_ASSERT( minimumDepth && maximumDepth );
|
||||
|
||||
double minValue = HUGE_VAL;
|
||||
double maxValue = -HUGE_VAL;
|
||||
|
||||
std::vector<double> depthValues = depthValuesByIntervals( depthType, depthUnit );
|
||||
for ( size_t vIdx = 0; vIdx < depthValues.size(); vIdx++ )
|
||||
{
|
||||
double value = depthValues[vIdx];
|
||||
|
||||
if ( value < minValue )
|
||||
{
|
||||
minValue = value;
|
||||
}
|
||||
|
||||
if ( value > maxValue )
|
||||
{
|
||||
maxValue = value;
|
||||
}
|
||||
}
|
||||
|
||||
if ( maxValue >= minValue )
|
||||
{
|
||||
*minimumDepth = minValue;
|
||||
*maximumDepth = maxValue;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RiaDefines::DepthUnitType RigWellLogCurveData::depthUnit() const
|
||||
{
|
||||
return m_depthUnit;
|
||||
}
|
||||
Reference in New Issue
Block a user