mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Adjustments before release
* Make sure existing project files do not filter intersection geometry by cell filters * #10241 Temporarily revert changes to resampling changes These fixes had unintended side effect on well flow plot and rft plots seen in regression tests https://github.com/OPM/ResInsight/issues/10241 * Update version number
This commit is contained in:
Magne Sjaastad
GitHub
@@ -345,52 +345,41 @@ cvf::ref<RigWellLogCurveData> RigWellLogCurveData::calculateResampledCurveData(
|
||||
return reSampledData;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellLogCurveData::interpolateSegment( RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
std::vector<double>& resampledValues,
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& resampledDepths,
|
||||
double targetDepthValue,
|
||||
size_t firstIndex,
|
||||
const std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& originalDepths,
|
||||
const std::vector<double>& propertyValues,
|
||||
double eps )
|
||||
void RigWellLogCurveData::interpolateSegment( RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
double depthValue,
|
||||
size_t firstIndex,
|
||||
std::vector<double>& xValues,
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>>& resampledDepths,
|
||||
const double eps ) const
|
||||
{
|
||||
if ( !originalDepths.contains( resamplingDepthType ) ) return;
|
||||
auto depthIt = m_depths.find( resamplingDepthType );
|
||||
|
||||
const size_t secondIndex = firstIndex + 1;
|
||||
const auto& depthValues = originalDepths.find( resamplingDepthType )->second;
|
||||
if ( secondIndex >= depthValues.size() ) return;
|
||||
size_t secondIndex = firstIndex + 1;
|
||||
|
||||
const double depth0 = depthValues[firstIndex];
|
||||
const double depth1 = depthValues[secondIndex];
|
||||
const double x0 = propertyValues[firstIndex];
|
||||
const double x1 = propertyValues[secondIndex];
|
||||
double slope = 0.0;
|
||||
double depth0 = depthIt->second[firstIndex];
|
||||
double depth1 = depthIt->second[secondIndex];
|
||||
double x0 = m_propertyValues[firstIndex];
|
||||
double x1 = m_propertyValues[secondIndex];
|
||||
double slope = 0.0;
|
||||
if ( std::fabs( depth1 - depth0 ) > eps )
|
||||
{
|
||||
slope = ( x1 - x0 ) / ( depth1 - depth0 );
|
||||
}
|
||||
const double resampledValue = slope * ( targetDepthValue - depth0 ) + x0;
|
||||
resampledValues.push_back( resampledValue );
|
||||
double xValue = slope * ( depthValue - depth0 ) + x0;
|
||||
xValues.push_back( xValue );
|
||||
|
||||
for ( const auto& [depthType, depthTypeValues] : originalDepths )
|
||||
for ( auto depthTypeValuesPair : m_depths )
|
||||
{
|
||||
// Skip the depth type we are resampling and ensure depth values are available
|
||||
if ( depthType == resamplingDepthType ) continue;
|
||||
if ( depthTypeValues.size() < secondIndex - 1 ) continue;
|
||||
|
||||
const double otherDepth0 = depthTypeValues[firstIndex];
|
||||
const double otherDepth1 = depthTypeValues[secondIndex];
|
||||
const double otherSlope = ( otherDepth1 - otherDepth0 ) / ( depth1 - depth0 );
|
||||
resampledDepths[depthType].push_back( otherSlope * ( targetDepthValue - depth0 ) + otherDepth0 );
|
||||
if ( depthTypeValuesPair.first != resamplingDepthType )
|
||||
{
|
||||
double otherDepth0 = depthTypeValuesPair.second[0];
|
||||
double otherDepth1 = depthTypeValuesPair.second[1];
|
||||
double otherSlope = ( otherDepth1 - otherDepth0 ) / ( depth1 - depth0 );
|
||||
resampledDepths[depthTypeValuesPair.first].push_back( otherSlope * ( depthValue - depth0 ) + otherDepth0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool isLeftOf( double x1, double x2, bool reverseOrder, double eps )
|
||||
{
|
||||
if ( reverseOrder )
|
||||
@@ -400,9 +389,6 @@ bool isLeftOf( double x1, double x2, bool reverseOrder, double eps )
|
||||
return x2 - x1 > eps;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool isRightOf( double x1, double x2, bool reverseOrder, double eps )
|
||||
{
|
||||
return isLeftOf( x2, x1, reverseOrder, eps );
|
||||
@@ -411,61 +397,53 @@ bool isRightOf( double x1, double x2, bool reverseOrder, double 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 )
|
||||
cvf::ref<RigWellLogCurveData> RigWellLogCurveData::calculateResampledCurveData( RiaDefines::DepthTypeEnum resamplingDepthType,
|
||||
const std::vector<double>& depths ) const
|
||||
{
|
||||
const double eps = 1.0e-8;
|
||||
|
||||
auto depthIt = originalDepths.find( resamplingDepthType );
|
||||
if ( depthIt == originalDepths.end() || depthIt->second.empty() ) return {};
|
||||
const auto& depthValues = depthIt->second;
|
||||
std::vector<double> xValues;
|
||||
|
||||
std::vector<double> resampledValues;
|
||||
std::map<RiaDefines::DepthTypeEnum, std::vector<double>> resampledDepths;
|
||||
resampledDepths.insert( std::make_pair( resamplingDepthType, targetDepths ) );
|
||||
resampledDepths.insert( std::make_pair( resamplingDepthType, depths ) );
|
||||
|
||||
cvf::ref<RigWellLogCurveData> resampledCurveData = new RigWellLogCurveData;
|
||||
auto depthIt = m_depths.find( resamplingDepthType );
|
||||
|
||||
cvf::ref<RigWellLogCurveData> reSampledData = new RigWellLogCurveData;
|
||||
|
||||
if ( depthIt == m_depths.end() || depthIt->second.empty() ) return reSampledData;
|
||||
|
||||
bool reverseOrder = resamplingDepthType == RiaDefines::DepthTypeEnum::CONNECTION_NUMBER;
|
||||
|
||||
size_t segmentSearchStartIdx = 0;
|
||||
for ( const auto& targetDepth : targetDepths )
|
||||
for ( auto depth : depths )
|
||||
{
|
||||
bool foundPoint = false;
|
||||
for ( size_t segmentStartIdx = segmentSearchStartIdx; segmentStartIdx < depthValues.size(); ++segmentStartIdx )
|
||||
for ( size_t segmentStartIdx = segmentSearchStartIdx; segmentStartIdx < depthIt->second.size(); ++segmentStartIdx )
|
||||
{
|
||||
if ( std::fabs( depthValues[segmentStartIdx] - targetDepth ) < eps ) // already have this depth point, reuse it
|
||||
if ( std::fabs( depthIt->second[segmentStartIdx] - depth ) < eps ) // already have this depth point,
|
||||
// reuse it
|
||||
{
|
||||
resampledValues.push_back( propertyValues[segmentStartIdx] );
|
||||
xValues.push_back( m_propertyValues[segmentStartIdx] );
|
||||
// Copy all depth types for this segment
|
||||
for ( const auto& depthTypeValuesPair : originalDepths )
|
||||
for ( auto depthTypeValuesPair : m_depths )
|
||||
{
|
||||
if ( depthTypeValuesPair.first != resamplingDepthType )
|
||||
{
|
||||
resampledDepths[depthTypeValuesPair.first].push_back( depthTypeValuesPair.second[segmentStartIdx] );
|
||||
}
|
||||
}
|
||||
segmentSearchStartIdx = segmentStartIdx;
|
||||
segmentSearchStartIdx = segmentStartIdx + 1;
|
||||
foundPoint = true;
|
||||
break;
|
||||
}
|
||||
else if ( segmentStartIdx < depthValues.size() - 1 )
|
||||
else if ( segmentStartIdx < depthIt->second.size() - 1 )
|
||||
{
|
||||
double minDepthSegment = std::min( depthValues[segmentStartIdx], depthValues[segmentStartIdx + 1] );
|
||||
double maxDepthSegment = std::max( depthValues[segmentStartIdx], depthValues[segmentStartIdx + 1] );
|
||||
if ( cvf::Math::valueInRange( targetDepth, minDepthSegment, maxDepthSegment ) )
|
||||
double minDepthSegment = std::min( depthIt->second[segmentStartIdx], depthIt->second[segmentStartIdx + 1] );
|
||||
double maxDepthSegment = std::max( depthIt->second[segmentStartIdx], depthIt->second[segmentStartIdx + 1] );
|
||||
if ( cvf::Math::valueInRange( depth, minDepthSegment, maxDepthSegment ) )
|
||||
{
|
||||
interpolateSegment( resamplingDepthType,
|
||||
resampledValues,
|
||||
resampledDepths,
|
||||
targetDepth,
|
||||
segmentStartIdx,
|
||||
originalDepths,
|
||||
propertyValues,
|
||||
eps );
|
||||
interpolateSegment( resamplingDepthType, depth, segmentStartIdx, xValues, resampledDepths, eps );
|
||||
segmentSearchStartIdx = segmentStartIdx;
|
||||
foundPoint = true;
|
||||
break;
|
||||
@@ -474,18 +452,17 @@ std::pair<std::vector<double>, std::map<RiaDefines::DepthTypeEnum, std::vector<d
|
||||
}
|
||||
if ( !foundPoint )
|
||||
{
|
||||
if ( isLeftOf( targetDepth, depthValues.front(), reverseOrder, eps ) )
|
||||
if ( isLeftOf( depth, depthIt->second.front(), reverseOrder, eps ) )
|
||||
{
|
||||
// Extrapolate from front two
|
||||
const size_t firstIndex = 0;
|
||||
interpolateSegment( resamplingDepthType, resampledValues, resampledDepths, targetDepth, firstIndex, originalDepths, propertyValues, eps );
|
||||
interpolateSegment( resamplingDepthType, depth, 0, xValues, resampledDepths, eps );
|
||||
foundPoint = true;
|
||||
}
|
||||
else if ( isRightOf( targetDepth, depthValues.back(), reverseOrder, eps ) )
|
||||
else if ( isRightOf( depth, depthIt->second.back(), reverseOrder, eps ) )
|
||||
{
|
||||
// Extrapolate from end two
|
||||
const size_t N = depthValues.size() - 1;
|
||||
interpolateSegment( resamplingDepthType, resampledValues, resampledDepths, targetDepth, N - 1, originalDepths, propertyValues, eps );
|
||||
const size_t N = depthIt->second.size() - 1;
|
||||
interpolateSegment( resamplingDepthType, depth, N - 1, xValues, resampledDepths, eps );
|
||||
foundPoint = true;
|
||||
}
|
||||
}
|
||||
@@ -493,18 +470,6 @@ std::pair<std::vector<double>, std::map<RiaDefines::DepthTypeEnum, std::vector<d
|
||||
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;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user