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

Improve RftPlt data source objects (#9769)

Browse Source 
Move AppEnum init to RifDataSourceForRftPlt
Simplify constructors for RifDataSourceForRftPlt
Rename enum names in RifDataSourceForRftPlt::SourceType
Add missing pressureDepthData in RimDataSourceForRftPlt
This commit is contained in:
Magne Sjaastad
2023-01-30 11:12:26 +01:00
committed by GitHub
parent 863925f980
commit 234719aea3
9 changed files with 366 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
ApplicationLibCode/FileInterface/RifDataSourceForRftPlt.cpp
View File

@@ -19,6 +19,7 @@
#include "RifDataSourceForRftPlt.h" #include "RifDataSourceForRftPlt.h"
#include "RifReaderEclipseRft.h" #include "RifReaderEclipseRft.h"
#include "RigEclipseCaseData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseResultCase.h" #include "RimEclipseResultCase.h"
@@ -34,6 +35,25 @@
#include <QString> #include <QString>
#include <QTextStream> #include <QTextStream>
namespace caf
{
template <>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem( RifDataSourceForRftPlt::SourceType::NONE, "NONE", "None" );
addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE, "OBSERVED", "Observed Data" );
addItem( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA, "RFT", "RFT Data" );
addItem( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, "GRID", "Grid Cases" );
addItem( RifDataSourceForRftPlt::SourceType::SUMMARY_RFT, "SUMMARY_RFT", "Summary Data" );
addItem( RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data" );
addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT, "OBSERVED_FMU", "Observed FMU Data" );
addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_PRESSURE_DEPTH,
"OBSERVED_PRESSURE_DEPTH",
"Observed Pressure/Depth Data" );
setDefault( RifDataSourceForRftPlt::SourceType::NONE );
}
} // namespace caf
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -47,7 +67,7 @@ RifDataSourceForRftPlt::RifDataSourceForRftPlt()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimEclipseCase* eclCase ) RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimEclipseCase* eclCase )
{ {
CVF_ASSERT( sourceType == SourceType::RFT || sourceType == SourceType::GRID ); CVF_ASSERT( sourceType == SourceType::RFT_SIM_WELL_DATA || sourceType == SourceType::GRID_MODEL_CELL_DATA );
CVF_ASSERT( eclCase != nullptr ); CVF_ASSERT( eclCase != nullptr );
m_sourceType = sourceType; m_sourceType = sourceType;
@@ -57,35 +77,27 @@ RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimEclips
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimWellLogFile* wellLogFile ) RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimWellLogFile* wellLogFile )
{ {
CVF_ASSERT( sourceType == SourceType::OBSERVED ); m_sourceType = SourceType::OBSERVED_LAS_FILE;
m_sourceType = sourceType;
m_wellLogFile = wellLogFile; m_wellLogFile = wellLogFile;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimSummaryCaseCollection* ensemble ) RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimSummaryCaseCollection* ensemble )
{ {
CVF_ASSERT( sourceType == SourceType::ENSEMBLE_RFT ); m_sourceType = SourceType::ENSEMBLE_RFT;
m_sourceType = sourceType;
m_ensemble = ensemble; m_ensemble = ensemble;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimSummaryCase* summaryCase, RimSummaryCaseCollection* ensemble )
RimSummaryCase* summaryCase,
RimSummaryCaseCollection* ensemble )
{ {
CVF_ASSERT( sourceType == SourceType::SUMMARY_RFT ); m_sourceType = SourceType::SUMMARY_RFT;
m_sourceType = sourceType;
m_summaryCase = summaryCase; m_summaryCase = summaryCase;
m_ensemble = ensemble; m_ensemble = ensemble;
} }
@@ -93,22 +105,18 @@ RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType source
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimObservedFmuRftData* observedFmuRftData ) RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimObservedFmuRftData* observedFmuRftData )
{ {
CVF_ASSERT( sourceType == SourceType::OBSERVED_FMU_RFT ); m_sourceType = SourceType::OBSERVED_FMU_RFT;
m_sourceType = sourceType;
m_observedFmuRftData = observedFmuRftData; m_observedFmuRftData = observedFmuRftData;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimPressureDepthData* observedFmuRftData ) RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimPressureDepthData* observedFmuRftData )
{ {
CVF_ASSERT( sourceType == SourceType::OBSERVED_FMU_RFT ); m_sourceType = SourceType::OBSERVED_FMU_RFT;
m_sourceType = sourceType;
m_pressureDepthData = observedFmuRftData; m_pressureDepthData = observedFmuRftData;
} }
@@ -128,25 +136,54 @@ RimEclipseCase* RifDataSourceForRftPlt::eclCase() const
return m_eclCase; return m_eclCase;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RiaDefines::EclipseUnitSystem> RifDataSourceForRftPlt::availableUnitSystems() const
{
std::vector<RiaDefines::EclipseUnitSystem> systems;
if ( m_eclCase && m_eclCase->eclipseCaseData() )
{
systems.push_back( m_eclCase->eclipseCaseData()->unitsType() );
}
if ( m_wellLogFile && m_wellLogFile->wellLogFileData() )
{
auto eclipseUnit = RiaDefines::fromDepthUnit( m_wellLogFile->wellLogFileData()->depthUnit() );
systems.push_back( eclipseUnit );
}
return systems;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifReaderRftInterface* RifDataSourceForRftPlt::rftReader() const RifReaderRftInterface* RifDataSourceForRftPlt::rftReader() const
{ {
if ( m_sourceType == RFT ) if ( m_sourceType == SourceType::GRID_MODEL_CELL_DATA || m_sourceType == SourceType::RFT_SIM_WELL_DATA )
{ {
auto eclResCase = dynamic_cast<RimEclipseResultCase*>( m_eclCase.p() ); // TODO: Consider changing to RimEclipseResultCase to avoid casting
auto eclResCase = dynamic_cast<RimEclipseResultCase*>( eclCase() );
if ( eclResCase ) return eclResCase->rftReader(); if ( eclResCase ) return eclResCase->rftReader();
} }
else if ( m_sourceType == SUMMARY_RFT ) else if ( m_sourceType == SourceType::SUMMARY_RFT )
{ {
if ( m_summaryCase ) return m_summaryCase->rftReader(); if ( m_summaryCase ) return m_summaryCase->rftReader();
} }
else if ( m_sourceType == ENSEMBLE_RFT ) else if ( m_sourceType == SourceType::ENSEMBLE_RFT )
{ {
if ( m_ensemble ) return m_ensemble->rftStatisticsReader(); if ( m_ensemble ) return m_ensemble->rftStatisticsReader();
} }
else if ( m_sourceType == SourceType::OBSERVED_FMU_RFT )
{
if ( m_observedFmuRftData ) return m_observedFmuRftData->rftReader();
}
else if ( m_sourceType == SourceType::OBSERVED_PRESSURE_DEPTH )
{
if ( m_pressureDepthData ) return m_pressureDepthData->rftReader();
}
return nullptr; return nullptr;
} }
@@ -197,11 +234,11 @@ QString RifDataSourceForRftPlt::sourceTypeUiText( SourceType sourceType )
{ {
switch ( sourceType ) switch ( sourceType )
{ {
case SourceType::RFT: case SourceType::RFT_SIM_WELL_DATA:
return QString( "RFT File Cases" ); return QString( "RFT File Cases" );
case SourceType::GRID: case SourceType::GRID_MODEL_CELL_DATA:
return QString( "Grid Cases" ); return QString( "Grid Cases" );
case SourceType::OBSERVED: case SourceType::OBSERVED_LAS_FILE:
return QString( "Observed Data" ); return QString( "Observed Data" );
case SourceType::ENSEMBLE_RFT: case SourceType::ENSEMBLE_RFT:
return QString( "Ensembles with RFT Data" ); return QString( "Ensembles with RFT Data" );
@@ -254,9 +291,9 @@ bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPl
return addr1.m_sourceType < addr2.m_sourceType; return addr1.m_sourceType < addr2.m_sourceType;
} }
if ( addr1.m_sourceType == RifDataSourceForRftPlt::NONE ) return false; // if ( addr1.m_sourceType == RifDataSourceForRftPlt::SourceType::NONE ) return false; //
if ( addr1.m_sourceType == RifDataSourceForRftPlt::OBSERVED ) if ( addr1.m_sourceType == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{ {
if ( addr1.wellLogFile() && addr2.wellLogFile() ) if ( addr1.wellLogFile() && addr2.wellLogFile() )
{ {
@@ -264,7 +301,7 @@ bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPl
} }
return addr1.wellLogFile() < addr2.wellLogFile(); return addr1.wellLogFile() < addr2.wellLogFile();
} }
else if ( addr1.m_sourceType == RifDataSourceForRftPlt::SUMMARY_RFT ) else if ( addr1.m_sourceType == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{ {
if ( addr1.summaryCase() && addr2.summaryCase() ) if ( addr1.summaryCase() && addr2.summaryCase() )
{ {
@@ -280,7 +317,7 @@ bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPl
} }
return addr1.summaryCase() < addr2.summaryCase(); return addr1.summaryCase() < addr2.summaryCase();
} }
else if ( addr1.m_sourceType == RifDataSourceForRftPlt::ENSEMBLE_RFT ) else if ( addr1.m_sourceType == RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT )
{ {
if ( addr1.ensemble() && addr2.ensemble() ) if ( addr1.ensemble() && addr2.ensemble() )
{ {
@@ -288,7 +325,7 @@ bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPl
} }
return addr1.ensemble() < addr2.ensemble(); return addr1.ensemble() < addr2.ensemble();
} }
else if ( addr1.m_sourceType == RifDataSourceForRftPlt::OBSERVED_FMU_RFT ) else if ( addr1.m_sourceType == RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT )
{ {
if ( addr1.observedFmuRftData() && addr2.observedFmuRftData() ) if ( addr1.observedFmuRftData() && addr2.observedFmuRftData() )
{ {

35
ApplicationLibCode/FileInterface/RifDataSourceForRftPlt.h
View File

@@ -44,41 +44,46 @@ class RimPressureDepthData;
class RifDataSourceForRftPlt class RifDataSourceForRftPlt
{ {
public: public:
enum SourceType enum class SourceType
{ {
NONE, NONE,
OBSERVED, RFT_SIM_WELL_DATA,
RFT, GRID_MODEL_CELL_DATA,
GRID,
ENSEMBLE_RFT,
SUMMARY_RFT, SUMMARY_RFT,
OBSERVED_FMU_RFT ENSEMBLE_RFT,
OBSERVED_LAS_FILE,
OBSERVED_FMU_RFT,
OBSERVED_PRESSURE_DEPTH
}; };
RifDataSourceForRftPlt(); RifDataSourceForRftPlt();
RifDataSourceForRftPlt( SourceType sourceType, RimEclipseCase* eclCase ); RifDataSourceForRftPlt( SourceType sourceType, RimEclipseCase* eclCase );
RifDataSourceForRftPlt( SourceType sourceType, RimSummaryCaseCollection* ensemble ); RifDataSourceForRftPlt( RimSummaryCaseCollection* ensemble );
RifDataSourceForRftPlt( SourceType sourceType, RimSummaryCase* summaryCase, RimSummaryCaseCollection* ensemble ); RifDataSourceForRftPlt( RimSummaryCase* summaryCase, RimSummaryCaseCollection* ensemble );
RifDataSourceForRftPlt( SourceType sourceType, RimWellLogFile* wellLogFile = nullptr ); RifDataSourceForRftPlt( RimWellLogFile* wellLogFile );
RifDataSourceForRftPlt( SourceType sourceType, RimObservedFmuRftData* observedFmuRftData ); RifDataSourceForRftPlt( RimObservedFmuRftData* observedFmuRftData );
RifDataSourceForRftPlt( SourceType sourceType, RimPressureDepthData* pressureDepthData ); RifDataSourceForRftPlt( RimPressureDepthData* pressureDepthData );
SourceType sourceType() const;
RifReaderRftInterface* rftReader() const;
SourceType sourceType() const;
RimEclipseCase* eclCase() const; RimEclipseCase* eclCase() const;
RifReaderRftInterface* rftReader() const;
RimSummaryCaseCollection* ensemble() const;
RimSummaryCase* summaryCase() const; RimSummaryCase* summaryCase() const;
RimSummaryCaseCollection* ensemble() const;
RimWellLogFile* wellLogFile() const; RimWellLogFile* wellLogFile() const;
RimObservedFmuRftData* observedFmuRftData() const; RimObservedFmuRftData* observedFmuRftData() const;
RimPressureDepthData* pressureDepthData() const; RimPressureDepthData* pressureDepthData() const;
static QString sourceTypeUiText( SourceType sourceType ); static QString sourceTypeUiText( SourceType sourceType );
std::vector<RiaDefines::EclipseUnitSystem> availableUnitSystems() const;
friend QTextStream& operator>>( QTextStream& str, RifDataSourceForRftPlt& addr ); friend QTextStream& operator>>( QTextStream& str, RifDataSourceForRftPlt& addr );
friend bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2 ); friend bool operator<( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2 );
private: private:
SourceType m_sourceType; SourceType m_sourceType;
caf::PdmPointer<RimEclipseCase> m_eclCase; caf::PdmPointer<RimEclipseCase> m_eclCase;
caf::PdmPointer<RimSummaryCase> m_summaryCase; caf::PdmPointer<RimSummaryCase> m_summaryCase;
caf::PdmPointer<RimSummaryCaseCollection> m_ensemble; caf::PdmPointer<RimSummaryCaseCollection> m_ensemble;

69
ApplicationLibCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.cpp
View File

@@ -19,28 +19,17 @@
#include "RimDataSourceForRftPlt.h" #include "RimDataSourceForRftPlt.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimObservedFmuRftData.h" #include "RimObservedFmuRftData.h"
#include "RimPressureDepthData.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h" #include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h" #include "RimWellLogFile.h"
#include "cafAppEnum.h" #include "cafAppEnum.h"
#include "cvfAssert.h" #include "cvfAssert.h"
#include <QString> #include <QString>
#include <QTextStream> #include <QTextStream>
namespace caf
{
template <>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem( RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases" );
addItem( RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases" );
addItem( RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data" );
addItem( RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data" );
addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT, "OBSERVED_FMU", "Observed FMU Data" );
setDefault( RifDataSourceForRftPlt::SourceType::NONE );
}
} // namespace caf
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -51,7 +40,7 @@ CAF_PDM_SOURCE_INIT( RimDataSourceForRftPlt, "RftAddress" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt() RimDataSourceForRftPlt::RimDataSourceForRftPlt()
{ {
InitPdmObject(); initPdmObject();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -59,7 +48,7 @@ RimDataSourceForRftPlt::RimDataSourceForRftPlt()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt( const RifDataSourceForRftPlt& addr ) RimDataSourceForRftPlt::RimDataSourceForRftPlt( const RifDataSourceForRftPlt& addr )
{ {
InitPdmObject(); initPdmObject();
setAddress( addr ); setAddress( addr );
} }
@@ -70,9 +59,11 @@ void RimDataSourceForRftPlt::setAddress( const RifDataSourceForRftPlt& address )
{ {
m_sourceType = address.sourceType(); m_sourceType = address.sourceType();
m_eclCase = address.eclCase(); m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile(); m_summaryCase = address.summaryCase();
m_ensemble = address.ensemble(); m_ensemble = address.ensemble();
m_wellLogFile = address.wellLogFile();
m_observedFmuRftData = address.observedFmuRftData(); m_observedFmuRftData = address.observedFmuRftData();
m_pressureDepthData = address.pressureDepthData();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -82,17 +73,20 @@ RifDataSourceForRftPlt RimDataSourceForRftPlt::address() const
{ {
switch ( m_sourceType() ) switch ( m_sourceType() )
{ {
case RifDataSourceForRftPlt::OBSERVED: case RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE:
return RifDataSourceForRftPlt( m_sourceType(), m_wellLogFile ); return RifDataSourceForRftPlt( m_wellLogFile );
case RifDataSourceForRftPlt::RFT: case RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA:
case RifDataSourceForRftPlt::GRID: return RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA, m_eclCase );
return RifDataSourceForRftPlt( m_sourceType(), m_eclCase ); case RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA:
case RifDataSourceForRftPlt::ENSEMBLE_RFT: return RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, m_eclCase );
return RifDataSourceForRftPlt( m_sourceType(), m_ensemble ); case RifDataSourceForRftPlt::SourceType::SUMMARY_RFT:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT: return RifDataSourceForRftPlt( m_summaryCase, m_ensemble );
return RifDataSourceForRftPlt( m_sourceType(), m_observedFmuRftData ); case RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT:
default: return RifDataSourceForRftPlt( m_ensemble );
break; case RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT:
return RifDataSourceForRftPlt( m_observedFmuRftData );
case RifDataSourceForRftPlt::SourceType::OBSERVED_PRESSURE_DEPTH:
return RifDataSourceForRftPlt( m_pressureDepthData );
} }
return RifDataSourceForRftPlt(); return RifDataSourceForRftPlt();
} }
@@ -100,24 +94,13 @@ RifDataSourceForRftPlt RimDataSourceForRftPlt::address() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimDataSourceForRftPlt::InitPdmObject() void RimDataSourceForRftPlt::initPdmObject()
{ {
CAF_PDM_InitFieldNoDefault( &m_sourceType, "SourceType", "Source Type" ); CAF_PDM_InitFieldNoDefault( &m_sourceType, "SourceType", "Source Type" );
CAF_PDM_InitFieldNoDefault( &m_eclCase, "EclipseCase", "Eclipse Case" ); CAF_PDM_InitFieldNoDefault( &m_eclCase, "EclipseCase", "Eclipse Case" );
CAF_PDM_InitFieldNoDefault( &m_wellLogFile, "WellLogFile", "Well Log File" ); CAF_PDM_InitFieldNoDefault( &m_summaryCase, "SummaryCase", "Summary Case" );
CAF_PDM_InitFieldNoDefault( &m_ensemble, "Ensemble", "Ensemble" ); CAF_PDM_InitFieldNoDefault( &m_ensemble, "Ensemble", "Ensemble" );
CAF_PDM_InitFieldNoDefault( &m_wellLogFile, "WellLogFile", "Well Log File" );
CAF_PDM_InitFieldNoDefault( &m_observedFmuRftData, "ObservedFmuRftData", "Observed FMU Data" ); CAF_PDM_InitFieldNoDefault( &m_observedFmuRftData, "ObservedFmuRftData", "Observed FMU Data" );
} CAF_PDM_InitFieldNoDefault( &m_pressureDepthData, "PressureDepthData", "Pressure/Depth Data" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt& RimDataSourceForRftPlt::operator=( const RimDataSourceForRftPlt& other )
{
m_sourceType = other.m_sourceType();
m_eclCase = other.m_eclCase();
m_wellLogFile = other.m_wellLogFile();
m_ensemble = other.m_ensemble();
m_observedFmuRftData = other.m_observedFmuRftData();
return *this;
} }

18
ApplicationLibCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.h
View File

@@ -50,17 +50,19 @@ public:
RimDataSourceForRftPlt(); RimDataSourceForRftPlt();
RimDataSourceForRftPlt( const RifDataSourceForRftPlt& addr ); RimDataSourceForRftPlt( const RifDataSourceForRftPlt& addr );
void setAddress( const RifDataSourceForRftPlt& address );
RifDataSourceForRftPlt address() const; RifDataSourceForRftPlt address() const;
RimDataSourceForRftPlt& operator=( const RimDataSourceForRftPlt& other ); private:
void initPdmObject();
void setAddress( const RifDataSourceForRftPlt& address );
private: private:
void InitPdmObject();
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType>> m_sourceType; caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType>> m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile; caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble; caf::PdmPtrField<RimSummaryCase*> m_summaryCase;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData; caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData;
caf::PdmPtrField<RimPressureDepthData*> m_pressureDepthData;
}; };

84
ApplicationLibCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@@ -538,7 +538,8 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::timeStep
{ {
timeStepsMap.insert( std::make_pair( timeStep, std::set<RifDataSourceForRftPlt>() ) ); timeStepsMap.insert( std::make_pair( timeStep, std::set<RifDataSourceForRftPlt>() ) );
} }
timeStepsMap[timeStep].insert( RifDataSourceForRftPlt( RifDataSourceForRftPlt::GRID, gridCase ) ); timeStepsMap[timeStep].insert(
RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, gridCase ) );
} }
} }
return timeStepsMap; return timeStepsMap;
@@ -630,7 +631,8 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
if ( rftCase != nullptr ) if ( rftCase != nullptr )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::RFT, rftCase ), return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA,
rftCase ),
wellName, wellName,
timeStep ); timeStep );
} }
@@ -639,30 +641,19 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
RimSummaryCaseCollection* parentEnsemble = nullptr; RimSummaryCaseCollection* parentEnsemble = nullptr;
rftSummaryCase->firstAncestorOrThisOfType( parentEnsemble ); rftSummaryCase->firstAncestorOrThisOfType( parentEnsemble );
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::SUMMARY_RFT, return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( rftSummaryCase, parentEnsemble ), wellName, timeStep );
rftSummaryCase,
parentEnsemble ),
wellName,
timeStep );
} }
else if ( rftEnsemble != nullptr ) else if ( rftEnsemble != nullptr )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::ENSEMBLE_RFT, rftEnsemble ), return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( rftEnsemble ), wellName, timeStep );
wellName,
timeStep );
} }
else if ( rftFmuData != nullptr ) else if ( rftFmuData != nullptr )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED_FMU_RFT, rftFmuData ), return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( rftFmuData ), wellName, timeStep );
wellName,
timeStep );
} }
else if ( pressureDepthData != nullptr ) else if ( pressureDepthData != nullptr )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED_FMU_RFT, return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( pressureDepthData ), wellName, timeStep );
pressureDepthData ),
wellName,
timeStep );
} }
} }
else if ( gridCurve != nullptr ) else if ( gridCurve != nullptr )
@@ -678,7 +669,8 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
timeStepsMap.end() ); timeStepsMap.end() );
if ( timeStepIndex < timeStepsMap.size() ) if ( timeStepIndex < timeStepsMap.size() )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::GRID, gridCase ), return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA,
gridCase ),
gridCurve->wellName(), gridCurve->wellName(),
timeStepsVector[timeStepIndex].first ); timeStepsVector[timeStepIndex].first );
} }
@@ -694,9 +686,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
if ( date.isValid() ) if ( date.isValid() )
{ {
return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED, wellLogFile ), return RiaRftPltCurveDefinition( RifDataSourceForRftPlt( wellLogFile ), wellLogFile->wellName(), date );
wellLogFile->wellName(),
date );
} }
} }
} }
@@ -760,7 +750,7 @@ std::set<RiaRftPltCurveDefinition>
for ( const RifDataSourceForRftPlt& addr : selectedSourcesExpanded ) for ( const RifDataSourceForRftPlt& addr : selectedSourcesExpanded )
{ {
if ( addr.sourceType() == RifDataSourceForRftPlt::RFT && addr.rftReader() ) if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA && addr.rftReader() )
{ {
std::set<QDateTime> rftTimes = addr.rftReader()->availableTimeSteps( simWellName, interestingRFTResults ); std::set<QDateTime> rftTimes = addr.rftReader()->availableTimeSteps( simWellName, interestingRFTResults );
for ( const QDateTime& time : rftTimes ) for ( const QDateTime& time : rftTimes )
@@ -771,7 +761,7 @@ std::set<RiaRftPltCurveDefinition>
} }
} }
} }
else if ( addr.sourceType() == RifDataSourceForRftPlt::GRID && addr.eclCase() ) else if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA && addr.eclCase() )
{ {
std::set<QDateTime> timeSteps = std::set<QDateTime> timeSteps =
RimWellPlotTools::availableSimWellTimesteps( addr.eclCase(), simWellName, firstSimWellTimeStepIsValid ); RimWellPlotTools::availableSimWellTimesteps( addr.eclCase(), simWellName, firstSimWellTimeStepIsValid );
@@ -784,7 +774,7 @@ std::set<RiaRftPltCurveDefinition>
} }
} }
} }
else if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED ) else if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{ {
if ( addr.wellLogFile() ) if ( addr.wellLogFile() )
{ {
@@ -794,7 +784,7 @@ std::set<RiaRftPltCurveDefinition>
} }
} }
} }
else if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT ) else if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT )
{ {
RimObservedFmuRftData* observedFmuRftData = addr.observedFmuRftData(); RimObservedFmuRftData* observedFmuRftData = addr.observedFmuRftData();
if ( observedFmuRftData && observedFmuRftData->rftReader() ) if ( observedFmuRftData && observedFmuRftData->rftReader() )
@@ -831,7 +821,7 @@ std::set<RiaRftPltCurveDefinition>
{ {
if ( summaryCase && summaryCase->rftReader() ) if ( summaryCase && summaryCase->rftReader() )
{ {
RifDataSourceForRftPlt summaryAddr( RifDataSourceForRftPlt::SUMMARY_RFT, summaryCase, addr.ensemble() ); RifDataSourceForRftPlt summaryAddr( summaryCase, addr.ensemble() );
std::set<QDateTime> timeSteps = std::set<QDateTime> timeSteps =
summaryCase->rftReader()->availableTimeSteps( wellPathNameOrSimWellName ); summaryCase->rftReader()->availableTimeSteps( wellPathNameOrSimWellName );
@@ -845,7 +835,7 @@ std::set<RiaRftPltCurveDefinition>
} }
} }
// Add statistics curves // Add statistics curves
if ( addr.sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT ) if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT )
{ {
std::set<QDateTime> statTimeSteps = addr.ensemble()->rftTimeStepsForWell( wellPathNameOrSimWellName ); std::set<QDateTime> statTimeSteps = addr.ensemble()->rftTimeStepsForWell( wellPathNameOrSimWellName );
for ( const QDateTime& time : statTimeSteps ) for ( const QDateTime& time : statTimeSteps )
@@ -857,12 +847,12 @@ std::set<RiaRftPltCurveDefinition>
} }
} }
} }
else if ( addr.sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT ) else if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{ {
auto summaryCase = addr.summaryCase(); auto summaryCase = addr.summaryCase();
if ( summaryCase && summaryCase->rftReader() ) if ( summaryCase && summaryCase->rftReader() )
{ {
RifDataSourceForRftPlt summaryAddr( RifDataSourceForRftPlt::SUMMARY_RFT, summaryCase, addr.ensemble() ); RifDataSourceForRftPlt summaryAddr( summaryCase, addr.ensemble() );
std::set<QDateTime> timeSteps = summaryCase->rftReader()->availableTimeSteps( wellPathNameOrSimWellName ); std::set<QDateTime> timeSteps = summaryCase->rftReader()->availableTimeSteps( wellPathNameOrSimWellName );
for ( const QDateTime& time : timeSteps ) for ( const QDateTime& time : timeSteps )
@@ -1124,20 +1114,20 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
switch ( source.sourceType() ) switch ( source.sourceType() )
{ {
case RifDataSourceForRftPlt::RFT: case RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA:
hasRftData = true; hasRftData = true;
break; break;
case RifDataSourceForRftPlt::GRID: case RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA:
hasGridData = true; hasGridData = true;
break; break;
case RifDataSourceForRftPlt::OBSERVED: case RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT: case RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT:
hasObservedData = true; hasObservedData = true;
break; break;
case RifDataSourceForRftPlt::SUMMARY_RFT: case RifDataSourceForRftPlt::SourceType::SUMMARY_RFT:
hasSummaryRftData = true; hasSummaryRftData = true;
break; break;
case RifDataSourceForRftPlt::ENSEMBLE_RFT: case RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT:
hasEnsembleData = true; hasEnsembleData = true;
break; break;
} }
@@ -1153,11 +1143,11 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
for ( const auto& source : selSources ) for ( const auto& source : selSources )
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::OBSERVED && source.wellLogFile() ) if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE && source.wellLogFile() )
{ {
observedTimeStepsWithSources[source.wellLogFile()->date()].insert( source ); observedTimeStepsWithSources[source.wellLogFile()->date()].insert( source );
} }
else if ( source.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT ) else if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT )
{ {
{ {
if ( source.observedFmuRftData() ) if ( source.observedFmuRftData() )
@@ -1187,7 +1177,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
for ( const auto& source : selSources ) for ( const auto& source : selSources )
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::RFT && source.rftReader() ) if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA && source.rftReader() )
{ {
std::set<QDateTime> rftTimes = source.rftReader()->availableTimeSteps( simWellName, interestingRFTResults ); std::set<QDateTime> rftTimes = source.rftReader()->availableTimeSteps( simWellName, interestingRFTResults );
for ( const QDateTime& date : rftTimes ) for ( const QDateTime& date : rftTimes )
@@ -1202,7 +1192,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
for ( const auto& source : selSources ) for ( const auto& source : selSources )
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::GRID && source.eclCase() ) if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA && source.eclCase() )
{ {
std::set<QDateTime> wellTimeSteps = std::set<QDateTime> wellTimeSteps =
RimWellPlotTools::availableSimWellTimesteps( source.eclCase(), simWellName, addFirstTimestep ); RimWellPlotTools::availableSimWellTimesteps( source.eclCase(), simWellName, addFirstTimestep );
@@ -1219,7 +1209,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
for ( const auto& source : selSources ) for ( const auto& source : selSources )
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT && source.summaryCase() && if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT && source.summaryCase() &&
source.summaryCase()->rftReader() ) source.summaryCase()->rftReader() )
{ {
std::set<QDateTime> wellTimeSteps = std::set<QDateTime> wellTimeSteps =
@@ -1237,7 +1227,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{ {
for ( const auto& source : selSources ) for ( const auto& source : selSources )
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT && source.ensemble() ) if ( source.sourceType() == RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT && source.ensemble() )
{ {
std::set<QDateTime> wellTimeSteps = source.ensemble()->rftTimeStepsForWell( wellPathNameOrSimWellName ); std::set<QDateTime> wellTimeSteps = source.ensemble()->rftTimeStepsForWell( wellPathNameOrSimWellName );
@@ -1390,20 +1380,20 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(
{ {
switch ( source.sourceType() ) switch ( source.sourceType() )
{ {
case RifDataSourceForRftPlt::OBSERVED: case RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT: case RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT:
hasObs = true; hasObs = true;
break; break;
case RifDataSourceForRftPlt::RFT: case RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA:
hasRft = true; hasRft = true;
break; break;
case RifDataSourceForRftPlt::GRID: case RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA:
hasGrid = true; hasGrid = true;
break; break;
case RifDataSourceForRftPlt::ENSEMBLE_RFT: case RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT:
hasEnsemble = true; hasEnsemble = true;
break; break;
case RifDataSourceForRftPlt::SUMMARY_RFT: case RifDataSourceForRftPlt::SourceType::SUMMARY_RFT:
hasRft = true; hasRft = true;
break; break;
} }

99
ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@@ -158,23 +158,14 @@ RimWellPltPlot::~RimWellPltPlot()
void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack ) void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
{ {
std::set<RiaDefines::EclipseUnitSystem> presentUnitSystems; std::set<RiaDefines::EclipseUnitSystem> presentUnitSystems;
for ( const RifDataSourceForRftPlt& source : m_selectedSources.v() ) for ( const auto& source : m_selectedSources() )
{ {
if ( source.eclCase() && source.eclCase()->eclipseCaseData() ) auto systems = source.availableUnitSystems();
for ( const auto& s : systems )
{ {
presentUnitSystems.insert( source.eclCase()->eclipseCaseData()->unitsType() ); presentUnitSystems.insert( s );
}
if ( source.wellLogFile() )
{
if ( source.wellLogFile()->wellLogFileData() )
{
auto eclipseUnit = RiaDefines::fromDepthUnit( source.wellLogFile()->wellLogFileData()->depthUnit() );
presentUnitSystems.insert( eclipseUnit );
}
} }
} }
if ( presentUnitSystems.size() > 1 ) if ( presentUnitSystems.size() > 1 )
{ {
RiaLogging::errorInMessageBox( nullptr, "ResInsight PLT Plot", "Inconsistent units in PLT plot" ); RiaLogging::errorInMessageBox( nullptr, "ResInsight PLT Plot", "Inconsistent units in PLT plot" );
@@ -261,7 +252,7 @@ std::set<RiaRftPltCurveDefinition> RimWellPltPlot::selectedCurveDefs() const
return RimWellPlotTools::curveDefsFromTimesteps( RimWellPlotTools::simWellName( m_wellPathName ), return RimWellPlotTools::curveDefsFromTimesteps( RimWellPlotTools::simWellName( m_wellPathName ),
m_selectedTimeSteps.v(), m_selectedTimeSteps.v(),
false, false,
selectedSourcesExpanded(), m_selectedSources(),
channelTypesToUse ); channelTypesToUse );
} }
@@ -519,18 +510,18 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
{ {
curveName += sourceDef.eclCase() ? sourceDef.eclCase()->caseUserDescription() : ""; curveName += sourceDef.eclCase() ? sourceDef.eclCase()->caseUserDescription() : "";
curveName += sourceDef.wellLogFile() ? sourceDef.wellLogFile()->name() : ""; curveName += sourceDef.wellLogFile() ? sourceDef.wellLogFile()->name() : "";
if ( sourceDef.sourceType() == RifDataSourceForRftPlt::RFT ) curveName += ", RFT"; if ( sourceDef.sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA ) curveName += ", RFT";
curveName += ", " + RiaQDateTimeTools::toStringUsingApplicationLocale( timeStep, dateFormatString ); curveName += ", " + RiaQDateTimeTools::toStringUsingApplicationLocale( timeStep, dateFormatString );
} }
RimEclipseResultCase* rimEclipseResultCase = dynamic_cast<RimEclipseResultCase*>( sourceDef.eclCase() ); RimEclipseResultCase* rimEclipseResultCase = dynamic_cast<RimEclipseResultCase*>( sourceDef.eclCase() );
if ( sourceDef.sourceType() == RifDataSourceForRftPlt::RFT ) if ( sourceDef.sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA )
{ {
resultPointCalc.reset( new RigRftResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) ); resultPointCalc.reset( new RigRftResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) );
} }
else if ( sourceDef.sourceType() == RifDataSourceForRftPlt::GRID ) else if ( sourceDef.sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA )
{ {
resultPointCalc.reset( new RigSimWellResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) ); resultPointCalc.reset( new RigSimWellResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) );
} }
@@ -546,7 +537,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
if ( !resultPointCalc->pipeBranchCLCoords().empty() ) if ( !resultPointCalc->pipeBranchCLCoords().empty() )
{ {
if ( selectedPhases.count( FLOW_PHASE_TOTAL ) && m_useReservoirConditionCurves() && if ( selectedPhases.count( FLOW_PHASE_TOTAL ) && m_useReservoirConditionCurves() &&
sourceDef.sourceType() == RifDataSourceForRftPlt::GRID ) sourceDef.sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA )
{ {
RigAccWellFlowCalculator wfTotalAccumulator( resultPointCalc->pipeBranchCLCoords(), RigAccWellFlowCalculator wfTotalAccumulator( resultPointCalc->pipeBranchCLCoords(),
resultPointCalc->pipeBranchWellResultPoints(), resultPointCalc->pipeBranchWellResultPoints(),
@@ -616,7 +607,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
} }
} }
} }
else if ( sourceDef.sourceType() == RifDataSourceForRftPlt::OBSERVED ) else if ( sourceDef.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{ {
if ( sourceDef.wellLogFile() && sourceDef.wellLogFile()->wellLogFileData() ) if ( sourceDef.wellLogFile() && sourceDef.wellLogFile()->wellLogFileData() )
{ {
@@ -727,27 +718,6 @@ void RimWellPltPlot::addStackedCurve( const QString& curveName,
plotTrack->addCurve( curve ); plotTrack->addCurve( curve );
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifDataSourceForRftPlt> RimWellPltPlot::selectedSourcesExpanded() const
{
std::vector<RifDataSourceForRftPlt> sources;
for ( const RifDataSourceForRftPlt& addr : m_selectedSources() )
{
if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED )
{
for ( RimWellLogFile* const wellLogFile : RimWellPlotTools::wellLogFilesContainingFlow( m_wellPathName ) )
{
sources.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED, wellLogFile ) );
}
}
else
sources.push_back( addr );
}
return sources;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -779,8 +749,6 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions( const caf::
} }
else if ( fieldNeedingOptions == &m_selectedSources ) else if ( fieldNeedingOptions == &m_selectedSources )
{ {
std::set<RifDataSourceForRftPlt> optionAddresses;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell( simWellName ); const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell( simWellName );
std::set<RifDataSourceForRftPlt> availableRftSources; std::set<RifDataSourceForRftPlt> availableRftSources;
@@ -792,15 +760,17 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions( const caf::
std::set<QDateTime> rftTimes = rftCase->rftReader()->availableTimeSteps( simWellName, channelTypesToUse ); std::set<QDateTime> rftTimes = rftCase->rftReader()->availableTimeSteps( simWellName, channelTypesToUse );
if ( !rftTimes.empty() ) if ( !rftTimes.empty() )
{ {
availableRftSources.insert( RifDataSourceForRftPlt( RifDataSourceForRftPlt::RFT, rftCase ) ); availableRftSources.insert(
RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA, rftCase ) );
} }
} }
if ( !availableRftSources.empty() ) if ( !availableRftSources.empty() )
{ {
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText( options.push_back(
RifDataSourceForRftPlt::RFT ), caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
true ) ); RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA ),
true ) );
for ( const auto& addr : availableRftSources ) for ( const auto& addr : availableRftSources )
{ {
@@ -813,30 +783,35 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions( const caf::
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell( simWellName ); const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell( simWellName );
if ( !gridCases.empty() ) if ( !gridCases.empty() )
{ {
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText( options.push_back(
RifDataSourceForRftPlt::GRID ), caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
true ) ); RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA ),
true ) );
} }
for ( const auto& gridCase : gridCases ) for ( const auto& gridCase : gridCases )
{ {
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::GRID, gridCase ); auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, gridCase );
auto item = caf::PdmOptionItemInfo( gridCase->caseUserDescription(), QVariant::fromValue( addr ) ); auto item = caf::PdmOptionItemInfo( gridCase->caseUserDescription(), QVariant::fromValue( addr ) );
item.setLevel( 1 ); item.setLevel( 1 );
options.push_back( item ); options.push_back( item );
} }
if ( !RimWellPlotTools::wellLogFilesContainingFlow( m_wellPathName ).empty() ) auto wellLogFiles = RimWellPlotTools::wellLogFilesContainingFlow( m_wellPathName );
if ( !wellLogFiles.empty() )
{ {
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText( options.push_back(
RifDataSourceForRftPlt::OBSERVED ), caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
true ) ); RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE ),
true ) );
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED ); for ( const auto& wellLogFile : wellLogFiles )
auto item = caf::PdmOptionItemInfo( "Observed Data", QVariant::fromValue( addr ) ); {
item.setLevel( 1 ); auto addr = RifDataSourceForRftPlt( wellLogFile );
options.push_back( item ); auto item = caf::PdmOptionItemInfo( wellLogFile->name(), QVariant::fromValue( addr ) );
optionAddresses.insert( addr ); item.setLevel( 1 );
options.push_back( item );
}
} }
} }
else if ( fieldNeedingOptions == &m_selectedTimeSteps ) else if ( fieldNeedingOptions == &m_selectedTimeSteps )
@@ -845,7 +820,7 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions( const caf::
RifEclipseRftAddress::pltPlotChannelTypes(); RifEclipseRftAddress::pltPlotChannelTypes();
RimWellPlotTools::calculateValueOptionsForTimeSteps( RimWellPlotTools::simWellName( m_wellPathName ), RimWellPlotTools::calculateValueOptionsForTimeSteps( RimWellPlotTools::simWellName( m_wellPathName ),
selectedSourcesExpanded(), m_selectedSources(),
channelTypesToUse, channelTypesToUse,
options ); options );
} }
@@ -894,8 +869,8 @@ void RimWellPltPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
{ {
for ( const RifDataSourceForRftPlt& address : m_selectedSources() ) for ( const RifDataSourceForRftPlt& address : m_selectedSources() )
{ {
if ( address.sourceType() == RifDataSourceForRftPlt::RFT || if ( address.sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA ||
address.sourceType() == RifDataSourceForRftPlt::GRID ) address.sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA )
{ {
if ( !wellPath->wellPathGeometry() ) if ( !wellPath->wellPathGeometry() )
{ {

2
ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.h
View File

@@ -104,8 +104,6 @@ private:
int curveGroupId, int curveGroupId,
bool doFillCurve ); bool doFillCurve );
std::vector<RifDataSourceForRftPlt> selectedSourcesExpanded() const;
// RimViewWindow overrides // RimViewWindow overrides
void setPlotXAxisTitles( RimWellLogTrack* plotTrack ); void setPlotXAxisTitles( RimWellLogTrack* plotTrack );

303
ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@@ -164,13 +164,13 @@ void RimWellRftPlot::applyCurveAppearance( RimWellLogCurve* curve )
RiuQwtPlotCurveDefines::LineStyleEnum lineStyle = RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_SOLID; RiuQwtPlotCurveDefines::LineStyleEnum lineStyle = RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_SOLID;
RiuPlotCurveSymbol::PointSymbolEnum currentSymbol = RiuPlotCurveSymbol::SYMBOL_NONE; RiuPlotCurveSymbol::PointSymbolEnum currentSymbol = RiuPlotCurveSymbol::SYMBOL_NONE;
if ( curveDef.address().sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT ) if ( curveDef.address().sourceType() != RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT )
{ {
currentSymbol = m_timeStepSymbols[curveDef.timeStep()]; currentSymbol = m_timeStepSymbols[curveDef.timeStep()];
} }
bool isObservedData = curveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED || bool isObservedData = curveDef.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE ||
curveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT; curveDef.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT;
// Observed data // Observed data
lineStyle = isObservedData ? RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_NONE lineStyle = isObservedData ? RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_NONE
: RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_SOLID; : RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_SOLID;
@@ -257,17 +257,19 @@ void RimWellRftPlot::applyInitialSelections()
for ( RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell( simWellName ) ) for ( RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell( simWellName ) )
{ {
sourcesToSelect.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::RFT, rftCase ) ); sourcesToSelect.push_back(
RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA, rftCase ) );
} }
for ( RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell( simWellName ) ) for ( RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell( simWellName ) )
{ {
sourcesToSelect.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::GRID, gridCase ) ); sourcesToSelect.push_back(
RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, gridCase ) );
} }
for ( RimSummaryCaseCollection* const ensemble : RimWellPlotTools::rftEnsemblesForWell( simWellName ) ) for ( RimSummaryCaseCollection* const ensemble : RimWellPlotTools::rftEnsemblesForWell( simWellName ) )
{ {
sourcesToSelect.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::ENSEMBLE_RFT, ensemble ) ); sourcesToSelect.push_back( RifDataSourceForRftPlt( ensemble ) );
} }
std::vector<RimWellLogFile*> wellLogFiles = std::vector<RimWellLogFile*> wellLogFiles =
@@ -276,14 +278,14 @@ void RimWellRftPlot::applyInitialSelections()
{ {
for ( RimWellLogFile* const wellLogFile : wellLogFiles ) for ( RimWellLogFile* const wellLogFile : wellLogFiles )
{ {
sourcesToSelect.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED, wellLogFile ) ); sourcesToSelect.push_back( RifDataSourceForRftPlt( wellLogFile ) );
} }
} }
for ( RimObservedFmuRftData* const observedFmuRftData : for ( RimObservedFmuRftData* const observedFmuRftData :
RimWellPlotTools::observedFmuRftDataForWell( m_wellPathNameOrSimWellName ) ) RimWellPlotTools::observedFmuRftDataForWell( m_wellPathNameOrSimWellName ) )
{ {
sourcesToSelect.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftData ) ); sourcesToSelect.push_back( RifDataSourceForRftPlt( observedFmuRftData ) );
} }
m_selectedSources = sourcesToSelect; m_selectedSources = sourcesToSelect;
@@ -377,12 +379,13 @@ void RimWellRftPlot::updateEditorsFromCurves()
for ( const RiaRftPltCurveDefinition& curveDef : curveDefsFromCurves() ) for ( const RiaRftPltCurveDefinition& curveDef : curveDefsFromCurves() )
{ {
if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ) if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
selectedSources.insert( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED ) );
else if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT )
{ {
selectedSources.insert( selectedSources.insert( RifDataSourceForRftPlt( curveDef.address().wellLogFile() ) );
RifDataSourceForRftPlt( RifDataSourceForRftPlt::ENSEMBLE_RFT, curveDef.address().ensemble() ) ); }
else if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{
selectedSources.insert( RifDataSourceForRftPlt( curveDef.address().ensemble() ) );
} }
else else
selectedSources.insert( curveDef.address() ); selectedSources.insert( curveDef.address() );
@@ -498,7 +501,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
// Add new curves // Add new curves
for ( const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs ) for ( const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs )
{ {
if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::RFT ) if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA )
{ {
auto curve = new RimWellLogRftCurve(); auto curve = new RimWellLogRftCurve();
plotTrack->addCurve( curve ); plotTrack->addCurve( curve );
@@ -516,7 +519,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
applyCurveAppearance( curve ); applyCurveAppearance( curve );
} }
else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT ) else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT )
{ {
auto curve = new RimWellLogRftCurve(); auto curve = new RimWellLogRftCurve();
plotTrack->addCurve( curve ); plotTrack->addCurve( curve );
@@ -540,7 +543,8 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
RiuQwtPlotCurveDefines::zDepthForIndex( RiuQwtPlotCurveDefines::ZIndex::Z_SINGLE_CURVE_OBSERVED ) ); RiuQwtPlotCurveDefines::zDepthForIndex( RiuQwtPlotCurveDefines::ZIndex::Z_SINGLE_CURVE_OBSERVED ) );
applyCurveAppearance( curve ); applyCurveAppearance( curve );
} }
else if ( m_showEnsembleCurves && curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT ) else if ( m_showEnsembleCurves &&
curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{ {
auto curve = new RimWellLogRftCurve(); auto curve = new RimWellLogRftCurve();
plotTrack->addCurve( curve ); plotTrack->addCurve( curve );
@@ -562,7 +566,8 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
curve->setShowInLegend( isFirstSummaryCurveInEnsemble ); curve->setShowInLegend( isFirstSummaryCurveInEnsemble );
ensemblesWithSummaryCurves.insert( curveDefToAdd.address().ensemble() ); ensemblesWithSummaryCurves.insert( curveDefToAdd.address().ensemble() );
} }
else if ( m_showStatisticsCurves && curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT ) else if ( m_showStatisticsCurves &&
curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT )
{ {
RimSummaryCaseCollection* ensemble = curveDefToAdd.address().ensemble(); RimSummaryCaseCollection* ensemble = curveDefToAdd.address().ensemble();
std::set<RifEclipseRftAddress> rftAddresses = std::set<RifEclipseRftAddress> rftAddresses =
@@ -606,7 +611,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
} }
} }
else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::GRID ) else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA )
{ {
auto curve = new RimWellLogExtractionCurve(); auto curve = new RimWellLogExtractionCurve();
plotTrack->addCurve( curve ); plotTrack->addCurve( curve );
@@ -643,7 +648,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
applyCurveAppearance( curve ); applyCurveAppearance( curve );
} }
} }
else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ) else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{ {
RimWellLogFile* const wellLogFile = curveDefToAdd.address().wellLogFile(); RimWellLogFile* const wellLogFile = curveDefToAdd.address().wellLogFile();
RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile( wellLogFile ); RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile( wellLogFile );
@@ -683,12 +688,12 @@ std::vector<RifDataSourceForRftPlt> RimWellRftPlot::selectedSourcesExpanded() co
std::vector<RifDataSourceForRftPlt> sources; std::vector<RifDataSourceForRftPlt> sources;
for ( const RifDataSourceForRftPlt& addr : m_selectedSources() ) for ( const RifDataSourceForRftPlt& addr : m_selectedSources() )
{ {
if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED ) if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{ {
for ( RimWellLogFile* const wellLogFile : for ( RimWellLogFile* const wellLogFile :
RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName ) ) RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName ) )
{ {
sources.push_back( RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED, wellLogFile ) ); sources.push_back( RifDataSourceForRftPlt( wellLogFile ) );
} }
} }
else else
@@ -785,120 +790,7 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions( const caf::
} }
else if ( fieldNeedingOptions == &m_selectedSources ) else if ( fieldNeedingOptions == &m_selectedSources )
{ {
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell( simWellName ); options = calculateValueOptionsForSources();
if ( !rftCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::RFT ),
true ) );
for ( const auto& rftCase : rftCases )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::RFT, rftCase );
auto item = caf::PdmOptionItemInfo( rftCase->caseUserDescription(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
const std::vector<RimSummaryCaseCollection*> rftEnsembles =
RimWellPlotTools::rftEnsemblesForWell( m_wellPathNameOrSimWellName );
if ( !rftEnsembles.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::ENSEMBLE_RFT ),
true ) );
for ( RimSummaryCaseCollection* rftEnsemble : rftEnsembles )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::ENSEMBLE_RFT, rftEnsemble );
auto item = caf::PdmOptionItemInfo( rftEnsemble->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
auto singleCases = RiaSummaryTools::singleTopLevelSummaryCases();
if ( !singleCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SUMMARY_RFT ),
true ) );
for ( auto summaryCase : singleCases )
{
if ( summaryCase->rftReader() &&
summaryCase->rftReader()->wellNames().contains( m_wellPathNameOrSimWellName ) )
{
RimSummaryCaseCollection* parentEnsemble = nullptr;
summaryCase->firstAncestorOrThisOfType( parentEnsemble );
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::SUMMARY_RFT, summaryCase, parentEnsemble );
auto item = caf::PdmOptionItemInfo( summaryCase->displayCaseName(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
}
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell( simWellName );
if ( !gridCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::GRID ),
true ) );
for ( const auto& gridCase : gridCases )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::GRID, gridCase );
auto item = caf::PdmOptionItemInfo( gridCase->caseUserDescription(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
if ( !RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName ).empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::OBSERVED ),
true ) );
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED );
auto item = caf::PdmOptionItemInfo( "Observed Data", QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
const std::vector<RimObservedFmuRftData*> observedFmuRftCases =
RimWellPlotTools::observedFmuRftDataForWell( m_wellPathNameOrSimWellName );
if ( !observedFmuRftCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::OBSERVED_FMU_RFT ),
true ) );
for ( const auto& observedFmuRftCase : observedFmuRftCases )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftCase );
auto item = caf::PdmOptionItemInfo( observedFmuRftCase->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
const std::vector<RimPressureDepthData*> pressureDepthData =
RimWellPlotTools::pressureDepthDataForWell( m_wellPathNameOrSimWellName );
if ( !pressureDepthData.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::OBSERVED_FMU_RFT ),
true ) );
for ( const auto& pd : pressureDepthData )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::OBSERVED_FMU_RFT, pd );
auto item = caf::PdmOptionItemInfo( pd->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
} }
else if ( fieldNeedingOptions == &m_selectedTimeSteps ) else if ( fieldNeedingOptions == &m_selectedTimeSteps )
{ {
@@ -919,6 +811,137 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions( const caf::
return options; return options;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptionsForSources() const
{
QList<caf::PdmOptionItemInfo> options;
const QString simWellName = associatedSimWellName();
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell( simWellName );
if ( !rftCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA ),
true ) );
for ( const auto& rftCase : rftCases )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::RFT_SIM_WELL_DATA, rftCase );
auto item = caf::PdmOptionItemInfo( rftCase->caseUserDescription(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
const std::vector<RimSummaryCaseCollection*> rftEnsembles =
RimWellPlotTools::rftEnsemblesForWell( m_wellPathNameOrSimWellName );
if ( !rftEnsembles.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT ),
true ) );
for ( RimSummaryCaseCollection* rftEnsemble : rftEnsembles )
{
auto addr = RifDataSourceForRftPlt( rftEnsemble );
auto item = caf::PdmOptionItemInfo( rftEnsemble->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
auto singleCases = RiaSummaryTools::singleTopLevelSummaryCases();
if ( !singleCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::SUMMARY_RFT ),
true ) );
for ( auto summaryCase : singleCases )
{
if ( summaryCase->rftReader() && summaryCase->rftReader()->wellNames().contains( m_wellPathNameOrSimWellName ) )
{
RimSummaryCaseCollection* parentEnsemble = nullptr;
summaryCase->firstAncestorOrThisOfType( parentEnsemble );
auto addr = RifDataSourceForRftPlt( summaryCase, parentEnsemble );
auto item = caf::PdmOptionItemInfo( summaryCase->displayCaseName(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
}
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell( simWellName );
if ( !gridCases.empty() )
{
options.push_back(
caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA ),
true ) );
for ( const auto& gridCase : gridCases )
{
auto addr = RifDataSourceForRftPlt( RifDataSourceForRftPlt::SourceType::GRID_MODEL_CELL_DATA, gridCase );
auto item = caf::PdmOptionItemInfo( gridCase->caseUserDescription(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
auto wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName );
if ( !wellLogFiles.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE ),
true ) );
for ( const auto& wellLogFile : wellLogFiles )
{
auto addr = RifDataSourceForRftPlt( wellLogFile );
auto item = caf::PdmOptionItemInfo( "Observed Data", QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
const std::vector<RimObservedFmuRftData*> observedFmuRftCases =
RimWellPlotTools::observedFmuRftDataForWell( m_wellPathNameOrSimWellName );
if ( !observedFmuRftCases.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT ),
true ) );
for ( const auto& observedFmuRftCase : observedFmuRftCases )
{
auto addr = RifDataSourceForRftPlt( observedFmuRftCase );
auto item = caf::PdmOptionItemInfo( observedFmuRftCase->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
const std::vector<RimPressureDepthData*> pressureDepthData =
RimWellPlotTools::pressureDepthDataForWell( m_wellPathNameOrSimWellName );
if ( !pressureDepthData.empty() )
{
options.push_back( caf::PdmOptionItemInfo::createHeader( RifDataSourceForRftPlt::sourceTypeUiText(
RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT ),
true ) );
for ( const auto& pd : pressureDepthData )
{
auto addr = RifDataSourceForRftPlt( pd );
auto item = caf::PdmOptionItemInfo( pd->name(), QVariant::fromValue( addr ) );
item.setLevel( 1 );
options.push_back( item );
}
}
return options;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -1281,7 +1304,7 @@ cvf::Color3f RimWellRftPlot::findCurveColor( RimWellLogCurve* curve )
RiaRftPltCurveDefinition curveDef = RimWellPlotTools::curveDefFromCurve( curve ); RiaRftPltCurveDefinition curveDef = RimWellPlotTools::curveDefFromCurve( curve );
cvf::Color3f curveColor; cvf::Color3f curveColor;
if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT ) if ( curveDef.address().sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{ {
RimWellRftEnsembleCurveSet* ensembleCurveSet = findEnsembleCurveSet( curveDef.address().ensemble() ); RimWellRftEnsembleCurveSet* ensembleCurveSet = findEnsembleCurveSet( curveDef.address().ensemble() );
if ( ensembleCurveSet && ensembleCurveSet->colorMode() == ColorMode::BY_ENSEMBLE_PARAM ) if ( ensembleCurveSet && ensembleCurveSet->colorMode() == ColorMode::BY_ENSEMBLE_PARAM )
@@ -1290,7 +1313,7 @@ cvf::Color3f RimWellRftPlot::findCurveColor( RimWellLogCurve* curve )
} }
else else
{ {
RifDataSourceForRftPlt sourceAddress( RifDataSourceForRftPlt::ENSEMBLE_RFT, curveDef.address().ensemble() ); RifDataSourceForRftPlt sourceAddress( curveDef.address().ensemble() );
curveColor = m_dataSourceColors[sourceAddress]; curveColor = m_dataSourceColors[sourceAddress];
} }
@@ -1380,9 +1403,9 @@ void RimWellRftPlot::defineCurveColorsAndSymbols( const std::set<RiaRftPltCurveD
const RifDataSourceForRftPlt& address = curveDefToAdd.address(); const RifDataSourceForRftPlt& address = curveDefToAdd.address();
RifDataSourceForRftPlt colorAddress = address; RifDataSourceForRftPlt colorAddress = address;
if ( address.sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT ) if ( address.sourceType() == RifDataSourceForRftPlt::SourceType::SUMMARY_RFT )
{ {
colorAddress = RifDataSourceForRftPlt( RifDataSourceForRftPlt::ENSEMBLE_RFT, address.ensemble() ); colorAddress = RifDataSourceForRftPlt( address.ensemble() );
} }
if ( !m_dataSourceColors.count( colorAddress ) ) if ( !m_dataSourceColors.count( colorAddress ) )
@@ -1391,7 +1414,7 @@ void RimWellRftPlot::defineCurveColorsAndSymbols( const std::set<RiaRftPltCurveD
m_dataSourceColors[colorAddress] = colorTable[colorTableIndex]; m_dataSourceColors[colorAddress] = colorTable[colorTableIndex];
} }
if ( address.sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT ) if ( address.sourceType() != RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT )
{ {
if ( !m_timeStepSymbols.count( curveDefToAdd.timeStep() ) ) if ( !m_timeStepSymbols.count( curveDefToAdd.timeStep() ) )
{ {

1
ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.h
View File

@@ -97,6 +97,7 @@ protected:
void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName ) override; void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override; QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptionsForSources() const;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override; void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void onLoadDataAndUpdate() override; void onLoadDataAndUpdate() override;