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

#11706 Use connection depths when plotting connection data

Browse Source 
The plotting of curve values for connections to a segment fails in some cases. The current implementation finds the segment a connection is attached to, and use the depth (both MD and TVD) information from this segment. This method is not working in all cases.

Use the reported location of connections attached to segments based on CONLENST and CONLENEN. When measured depth is requested, use these values. There might be gaps in the reported segment sequence.

Use CONDEPTH when TVD depth is requested.

Use CONBRNO to find the branch number, and then use lookup table branchIdsAndOneBasedBranchIndices to find the branch index. Use the branch index to filter the results for requested branch.

The number of values in CON* result values is different to result values for SEG* results.
This commit is contained in:
Magne Sjaastad 2024-09-17 11:28:50 +02:00
parent e006fe52c9
commit 48070f6539
10 changed files with 362 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
ApplicationLibCode/Application/RiaRftDefines.cpp
View File

@ -19,6 +19,14 @@
#include "RiaRftDefines.h"
#include "cafAppEnum.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaDefines::isSegmentResult( const QString& resultName )
{
return resultName.startsWith( "SEG" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -51,6 +59,78 @@ QString RiaDefines::segmentNumberResultName()
return "SEGMENTNUMBER";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaDefines::isSegmentConnectionResult( const QString& resultName )
{
return resultName.startsWith( "CON" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::segmentConnectionTvdDepthResultName()
{
return "CONDEPTH";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionEndDepthResultName()
{
return "CONLENEN";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionStartDepthResultName()
{
return "CONLENST";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionBranchNoResultName()
{
return "CONBRNO";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::segmentConnectionMeasuredDepthResultName()
{
return "SegmentConnectionMeasuredDepth";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionIPos()
{
return "CONIPOS";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionJPos()
{
return "CONJPOS";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiaDefines::segmentConnectionKPos()
{
return "CONKPOS";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

11
ApplicationLibCode/Application/RiaRftDefines.h
View File

@ -22,11 +22,22 @@
namespace RiaDefines
{
bool isSegmentResult( const QString& resultName );
QString segmentStartDepthResultName();
QString segmentEndDepthResultName();
QString segmentTvdDepthResultName();
QString segmentNumberResultName();
bool isSegmentConnectionResult( const QString& resultName );
QString segmentConnectionTvdDepthResultName();
std::string segmentConnectionEndDepthResultName();
std::string segmentConnectionStartDepthResultName();
std::string segmentConnectionBranchNoResultName();
QString segmentConnectionMeasuredDepthResultName();
std::string segmentConnectionIPos();
std::string segmentConnectionJPos();
std::string segmentConnectionKPos();
QString allBranches();
QString segmentBranchNumberResultName();

205
ApplicationLibCode/FileInterface/RifReaderOpmRft.cpp
View File

@ -119,6 +119,16 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
}
return;
}
else if ( rftAddress.segmentResultName() == RiaDefines::segmentConnectionMeasuredDepthResultName() )
{
auto segmentConnectionValues = segmentConnectionStartEndMeasuredDepth( rftAddress );
for ( const auto& [startMD, endMD, isValidSegment] : segmentConnectionValues )
{
values->push_back( endMD );
}
return;
}
}
if ( resultName.empty() )
@ -137,52 +147,19 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
auto key = std::make_pair( wellName, RftDate{ y, m, d } );
auto segment = m_rftWellDateSegments[key];
std::vector<size_t> nonContinuousDeviceSegmentIndices;
if ( rftAddress.segmentBranchType() == RiaDefines::RftBranchType::RFT_DEVICE )
{
nonContinuousDeviceSegmentIndices = segment.nonContinuousDeviceSegmentIndices( rftAddress.segmentBranchIndex() );
}
if ( m_connectionResultItemCount.count( wellName ) && data.size() == m_connectionResultItemCount[wellName] )
{
// Connection results with size equal to length of result CONSEGNO. CONSEGNO defines the segment
// numbers the connection is connected to.
const std::string consegResultName = "CONSEGNO";
auto connnectionSegmentNumbers = m_opm_rft->getRft<int>( consegResultName, wellName, y, m, d );
if ( connnectionSegmentNumbers.empty() ) return;
auto segmentNumbers =
segment.segmentNumbersForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
size_t resultDataIndex = 0;
for ( int segmentNumber : segmentNumbers )
{
auto segmentIndex = segment.segmentIndexFromSegmentNumber( segmentNumber );
if ( std::find( nonContinuousDeviceSegmentIndices.begin(), nonContinuousDeviceSegmentIndices.end(), segmentIndex ) !=
nonContinuousDeviceSegmentIndices.end() )
{
// Insert an extra infinity value for segments that are not continuous. The number of values in the values
// vector must be equal to the number of x-values (measured depths)
values->push_back( std::numeric_limits<double>::infinity() );
}
if ( std::find( connnectionSegmentNumbers.begin(), connnectionSegmentNumbers.end(), segmentNumber ) !=
connnectionSegmentNumbers.end() )
{
values->push_back( data[resultDataIndex++] );
}
else
{
// The number of values must be equal to the number of segments, use infinity for segments
// with no data
values->push_back( std::numeric_limits<double>::infinity() );
}
}
auto connectionValues = segmentConnectionValues( rftAddress, segment, data );
values->insert( values->end(), connectionValues.begin(), connectionValues.end() );
}
else
{
std::vector<size_t> nonContinuousDeviceSegmentIndices;
if ( rftAddress.segmentBranchType() == RiaDefines::RftBranchType::RFT_DEVICE )
{
nonContinuousDeviceSegmentIndices = segment.nonContinuousDeviceSegmentIndices( rftAddress.segmentBranchIndex() );
}
auto indices = segment.segmentIndicesForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
for ( const auto& i : indices )
{
@ -212,7 +189,7 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
if ( resultName == "CONFAC" || resultName == "CONKH" )
{
// Replace undefined values with zero to improve readability of plots
std::replace( values->begin(), values->end(), std::numeric_limits<double>::infinity(), 0.0 );
std::replace( data.begin(), data.end(), std::numeric_limits<double>::infinity(), 0.0 );
}
}
else
@ -335,14 +312,9 @@ std::vector<caf::VecIjk> RifReaderOpmRft::cellIndices( const QString& wellName,
try
{
auto resultNameI = "CONIPOS";
auto dataI = m_opm_rft->getRft<int>( resultNameI, stdWellName, y, m, d );
auto resultNameJ = "CONJPOS";
auto dataJ = m_opm_rft->getRft<int>( resultNameJ, stdWellName, y, m, d );
auto resultNameK = "CONKPOS";
auto dataK = m_opm_rft->getRft<int>( resultNameK, stdWellName, y, m, d );
auto dataI = m_opm_rft->getRft<int>( RiaDefines::segmentConnectionIPos(), stdWellName, y, m, d );
auto dataJ = m_opm_rft->getRft<int>( RiaDefines::segmentConnectionJPos(), stdWellName, y, m, d );
auto dataK = m_opm_rft->getRft<int>( RiaDefines::segmentConnectionKPos(), stdWellName, y, m, d );
if ( !dataI.empty() && ( dataI.size() == dataJ.size() ) && ( dataI.size() == dataK.size() ) )
{
@ -454,6 +426,134 @@ void RifReaderOpmRft::openFiles( const QString& fileName, const QString& dataDec
m_detectedErrorWhenOpeningRftFile = true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifReaderOpmRft::SegmentConnectionStartEnd>
RifReaderOpmRft::segmentConnectionStartEndMeasuredDepth( const RifEclipseRftAddress& rftAddress )
{
try
{
std::vector<RifReaderOpmRft::SegmentConnectionStartEnd> startEndValues;
if ( !isOpen() ) return startEndValues;
const int y = rftAddress.timeStep().date().year();
const int m = rftAddress.timeStep().date().month();
const int d = rftAddress.timeStep().date().day();
const std::string wellName = rftAddress.wellName().toStdString();
const std::string conbrnoResultName = RiaDefines::segmentConnectionBranchNoResultName();
const std::string conlenstResultName = RiaDefines::segmentConnectionStartDepthResultName();
const std::string conlenenResultName = RiaDefines::segmentConnectionEndDepthResultName();
const auto connnectionBranchNumbers = m_opm_rft->getRft<int>( conbrnoResultName, wellName, y, m, d );
const auto startMD = m_opm_rft->getRft<float>( conlenstResultName, wellName, y, m, d );
const auto endMD = m_opm_rft->getRft<float>( conlenenResultName, wellName, y, m, d );
const size_t size = connnectionBranchNumbers.size();
if ( size == startMD.size() && size == endMD.size() )
{
auto segment = segmentForWell( rftAddress.wellName(), rftAddress.timeStep() );
auto branchIdIndex = segment.branchIdsAndOneBasedBranchIndices( rftAddress.segmentBranchType() );
// Convert the branch number to the branch index
// Filter data based on branch index
bool isFirstSegment = true;
for ( size_t i = 0; i < connnectionBranchNumbers.size(); i++ )
{
if ( branchIdIndex.count( connnectionBranchNumbers[i] ) )
{
auto branchIndex = branchIdIndex[connnectionBranchNumbers[i]];
if ( branchIndex == rftAddress.segmentBranchIndex() )
{
if ( !isFirstSegment && std::fabs( startMD[i] - endMD[i - 1] ) > 0.1 )
{
// Insert a segment representing the connection between the segments. Assign infinity as value to this segment
// to allow discontinuous plotting.
startEndValues.emplace_back( endMD[i - 1], startMD[i], false );
}
startEndValues.emplace_back( startMD[i], endMD[i], true );
isFirstSegment = false;
}
}
}
}
return startEndValues;
}
catch ( ... )
{
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<float> RifReaderOpmRft::segmentConnectionValues( const RifEclipseRftAddress& rftAddress,
const RifRftSegment& rftSegment,
const std::vector<float>& nativeValues )
{
std::vector<float> branchValues;
const int y = rftAddress.timeStep().date().year();
const int m = rftAddress.timeStep().date().month();
const int d = rftAddress.timeStep().date().day();
const auto connnectionBranchNumbers =
m_opm_rft->getRft<int>( RiaDefines::segmentConnectionBranchNoResultName(), rftAddress.wellName().toStdString(), y, m, d );
if ( nativeValues.size() == connnectionBranchNumbers.size() )
{
auto branchIdIndex = rftSegment.branchIdsAndOneBasedBranchIndices( rftAddress.segmentBranchType() );
// Convert the branch number to the branch index
// Filter data based on branch index
for ( size_t i = 0; i < connnectionBranchNumbers.size(); i++ )
{
if ( branchIdIndex.count( connnectionBranchNumbers[i] ) )
{
auto branchIndex = branchIdIndex[connnectionBranchNumbers[i]];
if ( branchIndex == rftAddress.segmentBranchIndex() )
{
branchValues.push_back( nativeValues[i] );
}
}
}
}
std::vector<float> allResultValues;
auto segmentConnectionValues = segmentConnectionStartEndMeasuredDepth( rftAddress );
size_t segmentConnectionIndex = 0;
for ( auto branchValue : branchValues )
{
if ( segmentConnectionIndex < segmentConnectionValues.size() )
{
auto [startMD, endMD, isValidSegment] = segmentConnectionValues[segmentConnectionIndex];
if ( !isValidSegment )
{
// Use infinity to make sure no curve is drawn for this segment
allResultValues.push_back( std::numeric_limits<double>::infinity() );
segmentConnectionIndex++;
}
allResultValues.push_back( branchValue );
}
segmentConnectionIndex++;
}
return allResultValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -572,11 +672,12 @@ void RifReaderOpmRft::buildSegmentData()
for ( const auto& [name, arrayType, size] : results )
{
if ( ( name.find( "SEG" ) == 0 ) && m_segmentResultItemCount.count( wellName ) == 0 )
if ( ( RiaDefines::isSegmentResult( QString::fromStdString( name ) ) ) && m_segmentResultItemCount.count( wellName ) == 0 )
{
m_segmentResultItemCount[wellName] = size;
}
if ( name.find( "CON" ) == 0 && m_connectionResultItemCount.count( wellName ) == 0 )
if ( RiaDefines::isSegmentConnectionResult( QString::fromStdString( name ) ) &&
m_connectionResultItemCount.count( wellName ) == 0 )
{
m_connectionResultItemCount[wellName] = size;
}

7
ApplicationLibCode/FileInterface/RifReaderOpmRft.h
View File

@ -90,6 +90,13 @@ private:
bool openFiles();
using SegmentConnectionStartEnd = std::tuple<float, float, bool>;
std::vector<SegmentConnectionStartEnd> segmentConnectionStartEndMeasuredDepth( const RifEclipseRftAddress& rftAddress );
std::vector<float> segmentConnectionValues( const RifEclipseRftAddress& rftAddress,
const RifRftSegment& rftSegment,
const std::vector<float>& nativeValues );
private:
std::unique_ptr<Opm::EclIO::ERft> m_opm_rft;

102
ApplicationLibCode/ProjectDataModel/WellLog/RimRftTools.cpp
View File

@ -136,57 +136,54 @@ QList<caf::PdmOptionItemInfo>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimRftTools::segmentBranchIndexOptions( RifReaderRftInterface* readerRft,
QList<caf::PdmOptionItemInfo> RimRftTools::segmentBranchIndexOptions( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& timeStep,
RiaDefines::RftBranchType branchType )
{
auto opmReader = dynamic_cast<RifReaderOpmRft*>( readerRft );
if ( opmReader )
if ( !readerRft ) return {};
QList<caf::PdmOptionItemInfo> options;
options.push_front( caf::PdmOptionItemInfo( RiaDefines::allBranches(), -1 ) );
auto branchIdIndex = readerRft->branchIdsAndOneBasedIndices( wellName, timeStep, branchType );
std::set<int> indices;
for ( auto b : branchIdIndex )
{
QList<caf::PdmOptionItemInfo> options;
options.push_front( caf::PdmOptionItemInfo( RiaDefines::allBranches(), -1 ) );
auto branchIdIndex = opmReader->branchIdsAndOneBasedIndices( wellName, timeStep, branchType );
std::set<int> indices;
for ( auto b : branchIdIndex )
{
indices.insert( b.second );
}
for ( auto i : indices )
{
std::vector<int> branchIds;
for ( auto b : branchIdIndex )
{
if ( b.second == i ) branchIds.push_back( b.first );
}
auto minMax = std::minmax_element( branchIds.begin(), branchIds.end() );
auto txt = QString( "%1 (Branch Id %2-%3)" ).arg( i ).arg( *minMax.first ).arg( *minMax.second );
options.push_back( caf::PdmOptionItemInfo( txt, i ) );
}
return options;
indices.insert( b.second );
}
return {};
for ( auto i : indices )
{
std::vector<int> branchIds;
for ( auto b : branchIdIndex )
{
if ( b.second == i ) branchIds.push_back( b.first );
}
auto minMax = std::minmax_element( branchIds.begin(), branchIds.end() );
auto txt = QString( "%1 (Branch Id %2-%3)" ).arg( i ).arg( *minMax.first ).arg( *minMax.second );
options.push_back( caf::PdmOptionItemInfo( txt, i ) );
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RimRftTools::segmentStartMdValues( RifReaderRftInterface* readerRft,
std::vector<double> RimRftTools::segmentStartMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType )
{
std::vector<double> values;
if ( !readerRft ) return {};
auto resultNameSeglenst = RifEclipseRftAddress::createBranchSegmentAddress( wellName,
std::vector<double> values;
auto resultNameSeglenst = RifEclipseRftAddress::createBranchSegmentAddress( wellName,
dateTime,
RiaDefines::segmentStartDepthResultName(),
segmentBranchIndex,
@ -206,20 +203,43 @@ std::vector<double> RimRftTools::segmentStartMdValues( RifReaderRftInterface*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RimRftTools::segmentEndMdValues( RifReaderRftInterface* readerRft,
std::vector<double> RimRftTools::segmentEndMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType )
{
std::vector<double> values;
if ( !readerRft ) return {};
auto resultNameSeglenst = RifEclipseRftAddress::createBranchSegmentAddress( wellName,
dateTime,
RiaDefines::segmentEndDepthResultName(),
segmentBranchIndex,
segmentBranchType );
readerRft->values( resultNameSeglenst, &values );
std::vector<double> values;
auto resultAddress = RifEclipseRftAddress::createBranchSegmentAddress( wellName,
dateTime,
RiaDefines::segmentEndDepthResultName(),
segmentBranchIndex,
segmentBranchType );
readerRft->values( resultAddress, &values );
return values;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RimRftTools::segmentConnectionMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType )
{
if ( !readerRft ) return {};
std::vector<double> values;
auto resultAddress = RifEclipseRftAddress::createBranchSegmentAddress( wellName,
dateTime,
RiaDefines::segmentConnectionMeasuredDepthResultName(),
segmentBranchIndex,
segmentBranchType );
readerRft->values( resultAddress, &values );
return values;
}

14
ApplicationLibCode/ProjectDataModel/WellLog/RimRftTools.h
View File

@ -28,6 +28,7 @@ namespace caf
class PdmOptionItemInfo;
}
class RifReaderRftInterface;
class RifReaderOpmRft;
class RimRftTools
{
@ -41,20 +42,27 @@ public:
static QList<caf::PdmOptionItemInfo>
segmentResultNameOptions( RifReaderRftInterface* readerRft, const QString& wellName, const QDateTime& timeStep );
static QList<caf::PdmOptionItemInfo> segmentBranchIndexOptions( RifReaderRftInterface* readerRft,
static QList<caf::PdmOptionItemInfo> segmentBranchIndexOptions( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& timeStep,
RiaDefines::RftBranchType branchType );
static std::vector<double> segmentStartMdValues( RifReaderRftInterface* readerRft,
static std::vector<double> segmentStartMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType );
static std::vector<double> segmentEndMdValues( RifReaderRftInterface* readerRft,
static std::vector<double> segmentEndMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType );
static std::vector<double> segmentConnectionMdValues( RifReaderOpmRft* readerRft,
const QString& wellName,
const QDateTime& dateTime,
int segmentBranchIndex,
RiaDefines::RftBranchType segmentBranchType );
};

5
ApplicationLibCode/ProjectDataModel/WellLog/RimRftTopologyCurve.cpp
View File

@ -267,7 +267,10 @@ QList<caf::PdmOptionItemInfo> RimRftTopologyCurve::calculateValueOptions( const
}
else if ( fieldNeedingOptions == &m_segmentBranchIndex )
{
options = RimRftTools::segmentBranchIndexOptions( reader, m_wellName(), m_timeStep(), RiaDefines::RftBranchType::RFT_UNKNOWN );
options = RimRftTools::segmentBranchIndexOptions( dynamic_cast<RifReaderOpmRft*>( reader ),
m_wellName(),
m_timeStep(),
RiaDefines::RftBranchType::RFT_UNKNOWN );
}
return options;

7
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogCurveCommonDataSource.cpp
View File

@ -21,6 +21,8 @@
#include "RiaSimWellBranchTools.h"
#include "RiaSummaryTools.h"
#include "RifReaderOpmRft.h"
#include "RimCase.h"
#include "RimDataSourceSteppingTools.h"
#include "RimEclipseCase.h"
@ -1005,7 +1007,10 @@ QList<caf::PdmOptionItemInfo> RimWellLogCurveCommonDataSource::calculateValueOpt
}
else if ( fieldNeedingOptions == &m_rftSegmentBranchIndex )
{
options = RimRftTools::segmentBranchIndexOptions( rftReader(), m_rftWellName(), m_rftTimeStep(), m_rftSegmentBranchType() );
options = RimRftTools::segmentBranchIndexOptions( dynamic_cast<RifReaderOpmRft*>( rftReader() ),
m_rftWellName(),
m_rftTimeStep(),
m_rftSegmentBranchType() );
}
return options;

47
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogRftCurve.cpp
View File

@ -33,6 +33,7 @@
#include "RifEclipseRftAddress.h"
#include "RifReaderEclipseRft.h"
#include "RifReaderOpmRft.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseWellLogExtractor.h"
@ -572,7 +573,7 @@ std::map<QString, QString> RimWellLogRftCurve::createCurveNameKeyValueMap() cons
variableValueMap[RiaDefines::namingVariableWellBranch()] = branchText;
if ( isSegmentResult( m_segmentResultName() ) )
if ( RiaDefines::isSegmentResult( m_segmentResultName() ) )
{
variableValueMap[RiaDefines::namingVariableResultType()] = m_segmentBranchType().uiText();
}
@ -911,7 +912,8 @@ QList<caf::PdmOptionItemInfo> RimWellLogRftCurve::calculateValueOptions( const c
}
else if ( fieldNeedingOptions == &m_segmentBranchIndex )
{
options = RimRftTools::segmentBranchIndexOptions( reader, m_wellName(), m_timeStep(), m_segmentBranchType() );
options =
RimRftTools::segmentBranchIndexOptions( dynamic_cast<RifReaderOpmRft*>( reader ), m_wellName(), m_timeStep(), m_segmentBranchType() );
}
else if ( fieldNeedingOptions == &m_scaleFactor )
{
@ -1128,11 +1130,23 @@ std::vector<double> RimWellLogRftCurve::tvDepthValues()
if ( m_rftDataType() == RftDataType::RFT_SEGMENT_DATA )
{
depthAddress = RifEclipseRftAddress::createBranchSegmentAddress( m_wellName(),
m_timeStep,
RiaDefines::segmentTvdDepthResultName(),
segmentBranchIndex(),
m_segmentBranchType() );
if ( RiaDefines::isSegmentConnectionResult( m_segmentResultName ) )
{
depthAddress = RifEclipseRftAddress::createBranchSegmentAddress( m_wellName(),
m_timeStep,
RiaDefines::segmentConnectionTvdDepthResultName(),
segmentBranchIndex(),
m_segmentBranchType() );
}
else
{
depthAddress = RifEclipseRftAddress::createBranchSegmentAddress( m_wellName(),
m_timeStep,
RiaDefines::segmentTvdDepthResultName(),
segmentBranchIndex(),
m_segmentBranchType() );
}
}
reader->values( depthAddress, &values );
@ -1147,14 +1161,19 @@ std::vector<double> RimWellLogRftCurve::measuredDepthValues( QString& prefixText
{
if ( m_rftDataType() == RftDataType::RFT_SEGMENT_DATA )
{
RifReaderRftInterface* reader = rftReader();
if ( reader )
if ( auto opmRftReader = dynamic_cast<RifReaderOpmRft*>( rftReader() ) )
{
prefixText = "SEGMENT/";
if ( RiaDefines::isSegmentConnectionResult( m_segmentResultName() ) )
{
return RimRftTools::segmentConnectionMdValues( opmRftReader, m_wellName(), m_timeStep, segmentBranchIndex(), m_segmentBranchType() );
}
// Always use segment end MD values for segment data, as the curve is plotted as step left
return RimRftTools::segmentEndMdValues( reader, m_wellName(), m_timeStep, segmentBranchIndex(), m_segmentBranchType() );
return RimRftTools::segmentEndMdValues( opmRftReader, m_wellName(), m_timeStep, segmentBranchIndex(), m_segmentBranchType() );
}
return {};
}
@ -1238,11 +1257,3 @@ int RimWellLogRftCurve::segmentBranchIndex() const
{
return m_segmentBranchIndex();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellLogRftCurve::isSegmentResult( const QString& resultName )
{
return resultName.startsWith( "SEG" );
}

2
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogRftCurve.h
View File

@ -131,8 +131,6 @@ private:
int segmentBranchIndex() const;
static bool isSegmentResult( const QString& resultName );
private:
caf::PdmPtrField<RimEclipseCase*> m_eclipseCase;
caf::PdmPtrField<RimSummaryCase*> m_summaryCase;