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

Convert to enum class

Browse Source
This commit is contained in:
Magne Sjaastad 2020-04-23 23:25:22 +02:00
parent 8aa36ee31e
commit 3f88fe197a
56 changed files with 696 additions and 542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaApplication.cpp
View File

@ -567,7 +567,7 @@ bool RiaApplication::loadProject( const QString& projectFileName,
// If load action is specified to recalculate statistics, do it now. // If load action is specified to recalculate statistics, do it now.
// Apparently this needs to be done before the views are loaded, lest the number of time steps for statistics will // Apparently this needs to be done before the views are loaded, lest the number of time steps for statistics will
// be clamped // be clamped
if ( loadAction & int( ProjectLoadAction::PLA_CALCULATE_STATISTICS ) ) if ( loadAction == ProjectLoadAction::PLA_CALCULATE_STATISTICS )
{ {
for ( size_t oilFieldIdx = 0; oilFieldIdx < m_project->oilFields().size(); oilFieldIdx++ ) for ( size_t oilFieldIdx = 0; oilFieldIdx < m_project->oilFields().size(); oilFieldIdx++ )
{ {

2
ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp
View File

@ -86,7 +86,7 @@ void RiaCompletionTypeCalculationScheduler::scheduleRecalculateCompletionTypeAnd
{ {
eclipseCase->eclipseCaseData() eclipseCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::MATRIX_MODEL )
->clearScalarResult( RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName() ); ->clearScalarResult( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName() );
// Delete virtual perforation transmissibilities, as these are the basis for the computation of completion type // Delete virtual perforation transmissibilities, as these are the basis for the computation of completion type
eclipseCase->eclipseCaseData()->setVirtualPerforationTransmissibilities( nullptr ); eclipseCase->eclipseCaseData()->setVirtualPerforationTransmissibilities( nullptr );

20
ApplicationCode/Application/RiaDefines.cpp
View File

@ -27,16 +27,16 @@ namespace caf
template <> template <>
void caf::AppEnum<RiaDefines::ResultCatType>::setUp() void caf::AppEnum<RiaDefines::ResultCatType>::setUp()
{ {
addItem( RiaDefines::DYNAMIC_NATIVE, "DYNAMIC_NATIVE", "Dynamic" ); addItem( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "DYNAMIC_NATIVE", "Dynamic" );
addItem( RiaDefines::STATIC_NATIVE, "STATIC_NATIVE", "Static" ); addItem( RiaDefines::ResultCatType::STATIC_NATIVE, "STATIC_NATIVE", "Static" );
addItem( RiaDefines::SOURSIMRL, "SOURSIMRL", "SourSimRL" ); addItem( RiaDefines::ResultCatType::SOURSIMRL, "SOURSIMRL", "SourSimRL" );
addItem( RiaDefines::GENERATED, "GENERATED", "Generated" ); addItem( RiaDefines::ResultCatType::GENERATED, "GENERATED", "Generated" );
addItem( RiaDefines::INPUT_PROPERTY, "INPUT_PROPERTY", "Input Property" ); addItem( RiaDefines::ResultCatType::INPUT_PROPERTY, "INPUT_PROPERTY", "Input Property" );
addItem( RiaDefines::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names" ); addItem( RiaDefines::ResultCatType::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names" );
addItem( RiaDefines::ALLEN_DIAGRAMS, "ALLEN_DIAGRAMS", "Allen Diagrams" ); addItem( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, "ALLEN_DIAGRAMS", "Allen Diagrams" );
addItem( RiaDefines::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics" ); addItem( RiaDefines::ResultCatType::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics" );
addItem( RiaDefines::INJECTION_FLOODING, "INJECTION_FLOODING", "Injection Flooding" ); addItem( RiaDefines::ResultCatType::INJECTION_FLOODING, "INJECTION_FLOODING", "Injection Flooding" );
setDefault( RiaDefines::DYNAMIC_NATIVE ); setDefault( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
} }
template <> template <>

2
ApplicationCode/Application/RiaDefines.h
View File

@ -25,7 +25,7 @@
namespace RiaDefines namespace RiaDefines
{ {
enum ResultCatType enum class ResultCatType
{ {
DYNAMIC_NATIVE, DYNAMIC_NATIVE,
STATIC_NATIVE, STATIC_NATIVE,

2
ApplicationCode/Application/RiaMemoryCleanup.cpp
View File

@ -254,7 +254,7 @@ QList<caf::PdmOptionItemInfo> RiaMemoryCleanup::calculateValueOptions( const caf
const RigEclipseResultInfo* resInfo = caseData->resultInfo( resultAddr ); const RigEclipseResultInfo* resInfo = caseData->resultInfo( resultAddr );
QString posText = caf::AppEnum<RiaDefines::ResultCatType>::uiTextFromIndex( resInfo->resultType() ); QString posText = caf::AppEnum<RiaDefines::ResultCatType>::uiText( resInfo->resultType() );
QString resultsText = QString( "%1, %2" ).arg( posText ).arg( resInfo->resultName() ); QString resultsText = QString( "%1, %2" ).arg( posText ).arg( resInfo->resultName() );
if ( inUse ) if ( inUse )
{ {

2
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@ -270,7 +270,7 @@ bool RiaImportEclipseCaseTools::openEclipseInputCaseFromFileNames( const QString
RimEclipseView* riv = rimInputReservoir->createAndAddReservoirView(); RimEclipseView* riv = rimInputReservoir->createAndAddReservoirView();
riv->cellResult()->setResultType( RiaDefines::INPUT_PROPERTY ); riv->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY );
riv->loadDataAndUpdate(); riv->loadDataAndUpdate();

12
ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -192,7 +192,7 @@ std::vector<RigCompletionData>
if ( pdParams.performScaling ) if ( pdParams.performScaling )
{ {
RigCaseCellResultsData* results = caseToApply->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* results = caseToApply->results( RiaDefines::MATRIX_MODEL );
results->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PRESSURE" ) ); results->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) );
} }
return generateCompdatValuesConst( caseToApply, return generateCompdatValuesConst( caseToApply,
@ -266,8 +266,8 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
const std::vector<double>* currentMatrixPressures = nullptr; const std::vector<double>* currentMatrixPressures = nullptr;
if ( performPressureDepletionScaling ) if ( performPressureDepletionScaling )
{ {
pressureResultVector = pressureResultVector = &results->cellScalarResults(
&results->cellScalarResults( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PRESSURE" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) );
CVF_ASSERT( !pressureResultVector->empty() ); CVF_ASSERT( !pressureResultVector->empty() );
if ( pdParams.pressureScalingTimeStep < static_cast<int>( pressureResultVector->size() ) ) if ( pdParams.pressureScalingTimeStep < static_cast<int>( pressureResultVector->size() ) )
@ -832,9 +832,9 @@ void RicExportFractureCompletionsImpl::outputIntermediateResultsText( QTextStrea
bool RicExportFractureCompletionsImpl::loadResultsByName( RigCaseCellResultsData* cellResultsData, bool RicExportFractureCompletionsImpl::loadResultsByName( RigCaseCellResultsData* cellResultsData,
const std::vector<QString>& resultNames ) const std::vector<QString>& resultNames )
{ {
const std::vector<RiaDefines::ResultCatType> resultCategorySearchOrder = {RiaDefines::STATIC_NATIVE, const std::vector<RiaDefines::ResultCatType> resultCategorySearchOrder = {RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
RiaDefines::GENERATED}; RiaDefines::ResultCatType::GENERATED};
bool foundDataForAllResults = true; bool foundDataForAllResults = true;

90
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
View File

@ -1286,29 +1286,32 @@ CellDirection RicWellPathExportCompletionDataFeatureImpl::calculateCellMainDirec
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DX" ) );
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DY" ) );
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) );
double xLengthFraction = fabs( lengthsInCell.x() / dxAccessObject->cellScalarGlobIdx( globalCellIndex ) ); double xLengthFraction = fabs( lengthsInCell.x() / dxAccessObject->cellScalarGlobIdx( globalCellIndex ) );
double yLengthFraction = fabs( lengthsInCell.y() / dyAccessObject->cellScalarGlobIdx( globalCellIndex ) ); double yLengthFraction = fabs( lengthsInCell.y() / dyAccessObject->cellScalarGlobIdx( globalCellIndex ) );
@ -1345,54 +1348,60 @@ TransmissibilityData
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DX" ) );
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DY" ) );
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMX" ) );
cvf::ref<RigResultAccessor> permxAccessObject = cvf::ref<RigResultAccessor> permxAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) );
cvf::ref<RigResultAccessor> permyAccessObject = cvf::ref<RigResultAccessor> permyAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) );
cvf::ref<RigResultAccessor> permzAccessObject = cvf::ref<RigResultAccessor> permzAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMZ" ) );
if ( dxAccessObject.isNull() || dyAccessObject.isNull() || dzAccessObject.isNull() || permxAccessObject.isNull() || if ( dxAccessObject.isNull() || dyAccessObject.isNull() || dzAccessObject.isNull() || permxAccessObject.isNull() ||
permyAccessObject.isNull() || permzAccessObject.isNull() ) permyAccessObject.isNull() || permzAccessObject.isNull() )
@ -1404,14 +1413,15 @@ TransmissibilityData
{ {
// Trigger loading from file // Trigger loading from file
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
cvf::ref<RigResultAccessor> ntgAccessObject = cvf::ref<RigResultAccessor> ntgAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"NTG" ) );
if ( ntgAccessObject.notNull() ) if ( ntgAccessObject.notNull() )
{ {
@ -1495,13 +1505,14 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateDFactor( RimEclipseC
double porosity = 0.0; double porosity = 0.0;
{ {
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ) );
cvf::ref<RigResultAccessor> poroAccessObject = cvf::ref<RigResultAccessor> poroAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PORO" ) );
if ( poroAccessObject.notNull() ) if ( poroAccessObject.notNull() )
{ {
@ -1538,65 +1549,72 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEc
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DX" ) );
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DY" ) );
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMX" ) );
cvf::ref<RigResultAccessor> permxAccessObject = cvf::ref<RigResultAccessor> permxAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) );
cvf::ref<RigResultAccessor> permyAccessObject = cvf::ref<RigResultAccessor> permyAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) );
cvf::ref<RigResultAccessor> permzAccessObject = cvf::ref<RigResultAccessor> permzAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMZ" ) );
double ntg = 1.0; double ntg = 1.0;
if ( eclipseCase->results( RiaDefines::MATRIX_MODEL ) if ( eclipseCase->results( RiaDefines::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ) ) ->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) ) )
{ {
cvf::ref<RigResultAccessor> ntgAccessObject = cvf::ref<RigResultAccessor> ntgAccessObject =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"NTG" ) );
ntg = ntgAccessObject->cellScalarGlobIdx( globalCellIndex ); ntg = ntgAccessObject->cellScalarGlobIdx( globalCellIndex );
} }

19
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
View File

@ -165,8 +165,9 @@ void RicExportEclipseSectorModelUi::setCaseData( RigEclipseCaseData* caseData /*
{ {
for ( QString keyword : mainKeywords() ) for ( QString keyword : mainKeywords() )
{ {
if ( caseData && caseData->results( RiaDefines::MATRIX_MODEL ) if ( caseData &&
->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, keyword ) ) ) caseData->results( RiaDefines::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) )
{ {
selectedKeywords.v().push_back( keyword ); selectedKeywords.v().push_back( keyword );
} }
@ -177,8 +178,9 @@ void RicExportEclipseSectorModelUi::setCaseData( RigEclipseCaseData* caseData /*
std::vector<QString> validSelectedKeywords; std::vector<QString> validSelectedKeywords;
for ( QString keyword : selectedKeywords() ) for ( QString keyword : selectedKeywords() )
{ {
if ( caseData && caseData->results( RiaDefines::MATRIX_MODEL ) if ( caseData &&
->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, keyword ) ) ) caseData->results( RiaDefines::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) )
{ {
validSelectedKeywords.push_back( keyword ); validSelectedKeywords.push_back( keyword );
} }
@ -439,7 +441,8 @@ QList<caf::PdmOptionItemInfo>
{ {
RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::MATRIX_MODEL );
QList<caf::PdmOptionItemInfo> allOptions = QList<caf::PdmOptionItemInfo> allOptions =
RimEclipseResultDefinition::calcOptionsForVariableUiFieldStandard( RiaDefines::STATIC_NATIVE, resultData ); RimEclipseResultDefinition::calcOptionsForVariableUiFieldStandard( RiaDefines::ResultCatType::STATIC_NATIVE,
resultData );
std::set<QString> mainKeywords = this->mainKeywords(); std::set<QString> mainKeywords = this->mainKeywords();
for ( caf::PdmOptionItemInfo option : allOptions ) for ( caf::PdmOptionItemInfo option : allOptions )
@ -447,7 +450,7 @@ QList<caf::PdmOptionItemInfo>
if ( mainKeywords.count( option.optionUiText() ) ) if ( mainKeywords.count( option.optionUiText() ) )
{ {
if ( resultData->hasResultEntry( if ( resultData->hasResultEntry(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, option.optionUiText() ) ) ) RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, option.optionUiText() ) ) )
{ {
options.push_back( option ); options.push_back( option );
} }
@ -458,7 +461,7 @@ QList<caf::PdmOptionItemInfo>
if ( !mainKeywords.count( option.optionUiText() ) && option.optionUiText() != "None" ) if ( !mainKeywords.count( option.optionUiText() ) && option.optionUiText() != "None" )
{ {
if ( resultData->hasResultEntry( if ( resultData->hasResultEntry(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, option.optionUiText() ) ) ) RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, option.optionUiText() ) ) )
{ {
if ( option.optionUiText() == "ACTNUM" && exportGrid() ) if ( option.optionUiText() == "ACTNUM" && exportGrid() )
{ {
@ -606,7 +609,7 @@ void RicExportEclipseSectorModelUi::removeInvalidKeywords()
std::vector<QString> validKeywords; std::vector<QString> validKeywords;
for ( QString keyword : selectedKeywords() ) for ( QString keyword : selectedKeywords() )
{ {
if ( resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, keyword ) ) ) if ( resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) )
{ {
validKeywords.push_back( keyword ); validKeywords.push_back( keyword );
} }

2
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp
View File

@ -109,7 +109,7 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells( Rim
} }
viewToModify->setCurrentTimeStep( timeStep ); viewToModify->setCurrentTimeStep( timeStep );
viewToModify->cellResult()->setResultType( RiaDefines::FLOW_DIAGNOSTICS ); viewToModify->cellResult()->setResultType( RiaDefines::ResultCatType::FLOW_DIAGNOSTICS );
viewToModify->cellResult()->setResultVariable( "MaxFractionTracer" ); viewToModify->cellResult()->setResultVariable( "MaxFractionTracer" );
viewToModify->cellResult()->setFlowSolution( flowDiagSolution ); viewToModify->cellResult()->setFlowSolution( flowDiagSolution );

7
ApplicationCode/Commands/GridCrossPlotCommands/RicCreateSaturationPressurePlotsFeature.cpp
View File

@ -79,19 +79,20 @@ std::vector<RimSaturationPressurePlot*>
{ {
RigCaseCellResultsData* resultData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL );
if ( !resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PRESSURE" ) ) ) if ( !resultData->hasResultEntry(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) ) )
{ {
RiaLogging::error( "CreateSaturationPressurePlots : PRESSURE is not available " ); RiaLogging::error( "CreateSaturationPressurePlots : PRESSURE is not available " );
return plots; return plots;
} }
if ( !resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PDEW" ) ) ) if ( !resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PDEW" ) ) )
{ {
RiaLogging::error( "CreateSaturationPressurePlots : PDEW is not available " ); RiaLogging::error( "CreateSaturationPressurePlots : PDEW is not available " );
return plots; return plots;
} }
if ( !resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PBUB" ) ) ) if ( !resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PBUB" ) ) )
{ {
RiaLogging::error( "CreateSaturationPressurePlots : PBUB is not available " ); RiaLogging::error( "CreateSaturationPressurePlots : PBUB is not available " );
return plots; return plots;

2
ApplicationCode/Commands/RicNewContourMapViewFeature.cpp
View File

@ -235,7 +235,7 @@ RimEclipseContourMapView* RicNewContourMapViewFeature::createEclipseContourMap(
// Set default values // Set default values
{ {
contourMap->cellResult()->setResultType( RiaDefines::DYNAMIC_NATIVE ); contourMap->cellResult()->setResultType( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
if ( RiaApplication::instance()->preferences()->loadAndShowSoil ) if ( RiaApplication::instance()->preferences()->loadAndShowSoil )
{ {

4
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -462,7 +462,7 @@ bool RifEclipseInputFileTools::exportKeywords( const QString& resul
{ {
std::vector<double> resultValues; std::vector<double> resultValues;
RigEclipseResultAddress resAddr( RiaDefines::STATIC_NATIVE, keyword ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE, keyword );
if ( !cellResultsData->hasResultEntry( resAddr ) ) continue; if ( !cellResultsData->hasResultEntry( resAddr ) ) continue;
cellResultsData->ensureKnownResultLoaded( resAddr ); cellResultsData->ensureKnownResultLoaded( resAddr );
@ -910,7 +910,7 @@ bool RifEclipseInputFileTools::readDataFromKeyword( ecl_kw_type* eclipseK
} }
} }
RigEclipseResultAddress resAddr( RiaDefines::INPUT_PROPERTY, resultName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName );
caseData->results( RiaDefines::MATRIX_MODEL )->createResultEntry( resAddr, false ); caseData->results( RiaDefines::MATRIX_MODEL )->createResultEntry( resAddr, false );
auto newPropertyData = caseData->results( RiaDefines::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr ); auto newPropertyData = caseData->results( RiaDefines::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );

10
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -597,7 +597,7 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
for ( int i = 0; i < resultNames.size(); ++i ) for ( int i = 0; i < resultNames.size(); ++i )
{ {
RigEclipseResultAddress resAddr( RiaDefines::SOURSIMRL, resultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::SOURSIMRL, resultNames[i] );
matrixModelResults->createResultEntry( resAddr, false ); matrixModelResults->createResultEntry( resAddr, false );
matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos ); matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
@ -965,7 +965,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
for ( int i = 0; i < matrixResultNames.size(); ++i ) for ( int i = 0; i < matrixResultNames.size(); ++i )
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, matrixResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, matrixResultNames[i] );
matrixModelResults->createResultEntry( resAddr, false ); matrixModelResults->createResultEntry( resAddr, false );
matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos ); matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
@ -982,7 +982,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
for ( int i = 0; i < fractureResultNames.size(); ++i ) for ( int i = 0; i < fractureResultNames.size(); ++i )
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, fractureResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, fractureResultNames[i] );
fractureModelResults->createResultEntry( resAddr, false ); fractureModelResults->createResultEntry( resAddr, false );
fractureModelResults->setTimeStepInfos( resAddr, timeStepInfos ); fractureModelResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
@ -1059,7 +1059,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
for ( int i = 0; i < matrixResultNames.size(); ++i ) for ( int i = 0; i < matrixResultNames.size(); ++i )
{ {
RigEclipseResultAddress resAddr( RiaDefines::STATIC_NATIVE, matrixResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE, matrixResultNames[i] );
matrixModelResults->createResultEntry( resAddr, false ); matrixModelResults->createResultEntry( resAddr, false );
matrixModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo ); matrixModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo );
} }
@ -1078,7 +1078,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
for ( int i = 0; i < fractureResultNames.size(); ++i ) for ( int i = 0; i < fractureResultNames.size(); ++i )
{ {
RigEclipseResultAddress resAddr( RiaDefines::STATIC_NATIVE, fractureResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE, fractureResultNames[i] );
fractureModelResults->createResultEntry( resAddr, false ); fractureModelResults->createResultEntry( resAddr, false );
fractureModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo ); fractureModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo );
} }

7
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@ -53,7 +53,8 @@ bool RifReaderMockModel::open( const QString& fileName, RigEclipseCaseData* ecli
for ( size_t i = 0; i < m_reservoirBuilder.resultCount(); i++ ) for ( size_t i = 0; i < m_reservoirBuilder.resultCount(); i++ )
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, QString( "Dynamic_Result_%1" ).arg( i ) ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
QString( "Dynamic_Result_%1" ).arg( i ) );
cellResults->createResultEntry( resAddr, false ); cellResults->createResultEntry( resAddr, false );
cellResults->setTimeStepInfos( resAddr, timeStepInfos ); cellResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
@ -71,7 +72,7 @@ bool RifReaderMockModel::open( const QString& fileName, RigEclipseCaseData* ecli
int resIndex = 0; int resIndex = 0;
if ( i > 1 ) resIndex = i; if ( i > 1 ) resIndex = i;
RigEclipseResultAddress resAddr( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
QString( "Static_Result_%1%2" ).arg( resIndex ).arg( varEnd ) ); QString( "Static_Result_%1%2" ).arg( resIndex ).arg( varEnd ) );
cellResults->createResultEntry( resAddr, false ); cellResults->createResultEntry( resAddr, false );
@ -81,7 +82,7 @@ bool RifReaderMockModel::open( const QString& fileName, RigEclipseCaseData* ecli
#define ADD_INPUT_PROPERTY( Name ) \ #define ADD_INPUT_PROPERTY( Name ) \
{ \ { \
QString resultName( Name ); \ QString resultName( Name ); \
RigEclipseResultAddress resAddr( RiaDefines::INPUT_PROPERTY, resultName ); \ RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName ); \
cellResults->createResultEntry( resAddr, false ); \ cellResults->createResultEntry( resAddr, false ); \
cellResults->setTimeStepInfos( resAddr, staticResultTimeStepInfos ); \ cellResults->setTimeStepInfos( resAddr, staticResultTimeStepInfos ); \
cellResults->modifiableCellScalarResultTimesteps( resAddr )->resize( 1 ); \ cellResults->modifiableCellScalarResultTimesteps( resAddr )->resize( 1 ); \

2
ApplicationCode/GrpcInterface/RiaGrpcNNCPropertiesService.cpp
View File

@ -269,7 +269,7 @@ grpc::Status RiaGrpcNNCPropertiesService::GetAvailableNNCProperties( grpc::Serve
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
static bool scalarResultExistsOrCreate( RigCaseCellResultsData* results, QString propertyName ) static bool scalarResultExistsOrCreate( RigCaseCellResultsData* results, QString propertyName )
{ {
RigEclipseResultAddress resAddr( RiaDefines::GENERATED, propertyName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, propertyName );
if ( !results->ensureKnownResultLoaded( resAddr ) ) if ( !results->ensureKnownResultLoaded( resAddr ) )
{ {

9
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -163,16 +163,17 @@ void RivNNCGeometryGenerator::textureCoordinates( cvf::Vec2fArray*
textureCoords->resize( numVertices ); textureCoords->resize( numVertices );
cvf::Vec2f* rawPtr = textureCoords->ptr(); cvf::Vec2f* rawPtr = textureCoords->ptr();
const std::vector<double>* nncResultVals = nullptr; const std::vector<double>* nncResultVals = nullptr;
if ( resultType == RiaDefines::STATIC_NATIVE || resultType == RiaDefines::FORMATION_NAMES || if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE ||
resultType == RiaDefines::ALLEN_DIAGRAMS ) resultType == RiaDefines::ResultCatType::FORMATION_NAMES ||
resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
nncResultVals = m_nncData->staticConnectionScalarResult( resVarAddr ); nncResultVals = m_nncData->staticConnectionScalarResult( resVarAddr );
} }
else if ( resultType == RiaDefines::DYNAMIC_NATIVE ) else if ( resultType == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
{ {
nncResultVals = m_nncData->dynamicConnectionScalarResult( resVarAddr, nativeTimeStepIndex ); nncResultVals = m_nncData->dynamicConnectionScalarResult( resVarAddr, nativeTimeStepIndex );
} }
else if ( resultType == RiaDefines::GENERATED ) else if ( resultType == RiaDefines::ResultCatType::GENERATED )
{ {
nncResultVals = m_nncData->generatedConnectionScalarResult( resVarAddr, nativeTimeStepIndex ); nncResultVals = m_nncData->generatedConnectionScalarResult( resVarAddr, nativeTimeStepIndex );
} }

2
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp
View File

@ -169,7 +169,7 @@ void RivReservoirFaultsPartMgr::appendPartsToModel( cvf::ModelBasicList* model )
eclipseResultAddress = cellResultColors->eclipseResultAddress(); eclipseResultAddress = cellResultColors->eclipseResultAddress();
} }
if ( eclipseResultAddress.m_resultCatType == RiaDefines::ALLEN_DIAGRAMS ) if ( eclipseResultAddress.m_resultCatType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
showCompleteNncGeo = true; showCompleteNncGeo = true;
} }

2
ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
View File

@ -546,7 +546,7 @@ void RimFlowCharacteristicsPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
if ( view != nullptr ) if ( view != nullptr )
{ {
view->faultCollection()->showFaultCollection = false; view->faultCollection()->showFaultCollection = false;
view->cellResult()->setResultType( RiaDefines::FLOW_DIAGNOSTICS ); view->cellResult()->setResultType( RiaDefines::ResultCatType::FLOW_DIAGNOSTICS );
view->cellResult()->setFlowDiagTracerSelectionType( RimEclipseResultDefinition::FLOW_TR_BY_SELECTION ); view->cellResult()->setFlowDiagTracerSelectionType( RimEclipseResultDefinition::FLOW_TR_BY_SELECTION );
view->cellResult()->setSelectedTracers( m_selectedTracerNames ); view->cellResult()->setSelectedTracers( m_selectedTracerNames );

7
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@ -116,9 +116,10 @@ std::pair<RigEclipseResultAddress, QString>
for ( const auto& pressureDataName : PRESSURE_DATA_NAMES ) for ( const auto& pressureDataName : PRESSURE_DATA_NAMES )
{ {
if ( eclipseCaseData->results( RiaDefines::MATRIX_MODEL ) if ( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, pressureDataName ) ) ) ->hasResultEntry(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, pressureDataName ) ) )
{ {
return std::make_pair( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, pressureDataName ), return std::make_pair( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, pressureDataName ),
pressureDataName ); pressureDataName );
} }
} }
@ -233,7 +234,7 @@ bool RimWellPlotTools::hasFlowData( RimEclipseResultCase* gridCase )
for ( const QString& channelName : FLOW_DATA_NAMES ) for ( const QString& channelName : FLOW_DATA_NAMES )
{ {
if ( eclipseCaseData->results( RiaDefines::MATRIX_MODEL ) if ( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, channelName ) ) ) ->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, channelName ) ) )
{ {
return true; return true;
} }

10
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
View File

@ -164,7 +164,7 @@ void RimGridCrossPlotDataSet::setCellFilterView( RimGridView* cellFilterView )
{ {
m_xAxisProperty->setResultType( resAddr.m_resultCatType ); m_xAxisProperty->setResultType( resAddr.m_resultCatType );
m_xAxisProperty->setResultVariable( resAddr.m_resultName ); m_xAxisProperty->setResultVariable( resAddr.m_resultName );
m_yAxisProperty->setResultType( RiaDefines::STATIC_NATIVE ); m_yAxisProperty->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
m_yAxisProperty->setResultVariable( "DEPTH" ); m_yAxisProperty->setResultVariable( "DEPTH" );
m_timeStep = eclipseView->currentTimeStep(); m_timeStep = eclipseView->currentTimeStep();
m_grouping = NO_GROUPING; m_grouping = NO_GROUPING;
@ -1183,11 +1183,11 @@ void RimGridCrossPlotDataSet::configureForPressureSaturationCurves( RimEclipseRe
m_case = eclipseCase; m_case = eclipseCase;
m_xAxisProperty->setEclipseCase( eclipseCase ); m_xAxisProperty->setEclipseCase( eclipseCase );
m_xAxisProperty->setResultType( RiaDefines::DYNAMIC_NATIVE ); m_xAxisProperty->setResultType( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
m_xAxisProperty->setResultVariable( dynamicResultName ); m_xAxisProperty->setResultVariable( dynamicResultName );
m_yAxisProperty->setEclipseCase( eclipseCase ); m_yAxisProperty->setEclipseCase( eclipseCase );
m_yAxisProperty->setResultType( RiaDefines::STATIC_NATIVE ); m_yAxisProperty->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
m_yAxisProperty->setResultVariable( "DEPTH" ); m_yAxisProperty->setResultVariable( "DEPTH" );
m_grouping = NO_GROUPING; m_grouping = NO_GROUPING;
@ -1298,10 +1298,10 @@ void RimGridCrossPlotDataSet::setDefaults()
m_yAxisProperty->setEclipseCase( eclipseCase ); m_yAxisProperty->setEclipseCase( eclipseCase );
m_groupingProperty->setEclipseCase( eclipseCase ); m_groupingProperty->setEclipseCase( eclipseCase );
m_xAxisProperty->setResultType( RiaDefines::STATIC_NATIVE ); m_xAxisProperty->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
m_xAxisProperty->setResultVariable( "PORO" ); m_xAxisProperty->setResultVariable( "PORO" );
m_yAxisProperty->setResultType( RiaDefines::STATIC_NATIVE ); m_yAxisProperty->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
m_yAxisProperty->setResultVariable( "PERMX" ); m_yAxisProperty->setResultVariable( "PERMX" );
m_grouping = NO_GROUPING; m_grouping = NO_GROUPING;

10
ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlot.cpp
View File

@ -105,7 +105,7 @@ void RimSaturationPressurePlot::assignCaseAndEquilibriumRegion( RiaDefines::Poro
RigCaseCellResultsData* caseCellResultsData = eclipseResultCase->eclipseCaseData()->results( porosityModel ); RigCaseCellResultsData* caseCellResultsData = eclipseResultCase->eclipseCaseData()->results( porosityModel );
if ( caseCellResultsData ) if ( caseCellResultsData )
{ {
RigEclipseResultAddress depthResultAddress( RiaDefines::STATIC_NATIVE, "DEPTH" ); RigEclipseResultAddress depthResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DEPTH" );
double minDepth = 0.0; double minDepth = 0.0;
double maxDepth = 0.0; double maxDepth = 0.0;
@ -136,7 +136,7 @@ void RimSaturationPressurePlot::assignCaseAndEquilibriumRegion( RiaDefines::Poro
{ {
RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition(); RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition();
resultDefinition->setEclipseCase( eclipseResultCase ); resultDefinition->setEclipseCase( eclipseResultCase );
resultDefinition->setResultType( RiaDefines::STATIC_NATIVE ); resultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() ); resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() );
cellFilter->setResultDefinition( resultDefinition ); cellFilter->setResultDefinition( resultDefinition );
@ -151,7 +151,7 @@ void RimSaturationPressurePlot::assignCaseAndEquilibriumRegion( RiaDefines::Poro
RigCaseCellResultsData* caseCellResultsData = eclipseResultCase->eclipseCaseData()->results( porosityModel ); RigCaseCellResultsData* caseCellResultsData = eclipseResultCase->eclipseCaseData()->results( porosityModel );
if ( caseCellResultsData ) if ( caseCellResultsData )
{ {
RigEclipseResultAddress depthResultAddress( RiaDefines::STATIC_NATIVE, "DEPTH" ); RigEclipseResultAddress depthResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DEPTH" );
double minDepth = 0.0; double minDepth = 0.0;
double maxDepth = 0.0; double maxDepth = 0.0;
@ -244,7 +244,7 @@ RimPlotCellPropertyFilter*
RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition(); RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition();
resultDefinition->setEclipseCase( eclipseResultCase ); resultDefinition->setEclipseCase( eclipseResultCase );
resultDefinition->setResultType( RiaDefines::STATIC_NATIVE ); resultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() ); resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() );
cellFilter->setResultDefinition( resultDefinition ); cellFilter->setResultDefinition( resultDefinition );
@ -265,7 +265,7 @@ RimPlotCellPropertyFilter* RimSaturationPressurePlot::createDepthPropertyFilter(
RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition(); RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition();
resultDefinition->setEclipseCase( eclipseResultCase ); resultDefinition->setEclipseCase( eclipseResultCase );
resultDefinition->setResultType( RiaDefines::STATIC_NATIVE ); resultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
resultDefinition->setResultVariable( "DEPTH" ); resultDefinition->setResultVariable( "DEPTH" );
depthCellFilter->setResultDefinition( resultDefinition ); depthCellFilter->setResultDefinition( resultDefinition );

2
ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
View File

@ -67,7 +67,7 @@ std::vector<RimSaturationPressurePlot*>
std::set<int> eqlnumRegionIdsFound; std::set<int> eqlnumRegionIdsFound;
{ {
RigEclipseResultAddress resAdr( RiaDefines::STATIC_NATIVE, RiaDefines::eqlnumResultName() ); RigEclipseResultAddress resAdr( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::eqlnumResultName() );
if ( results->hasResultEntry( resAdr ) ) if ( results->hasResultEntry( resAdr ) )
{ {
results->ensureKnownResultLoaded( resAdr ); results->ensureKnownResultLoaded( resAdr );

56
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -1246,40 +1246,40 @@ std::vector<RigEclipseResultAddress> sourcesForMultiPropertyResults( const QStri
{ {
static const std::map<QString, std::vector<RigEclipseResultAddress>> resultsWithMultiPropertySource = static const std::map<QString, std::vector<RigEclipseResultAddress>> resultsWithMultiPropertySource =
{{RiaDefines::combinedTransmissibilityResultName(), {{RiaDefines::combinedTransmissibilityResultName(),
{RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANX" ), {RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANY" ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANZ" )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" )}},
{RiaDefines::combinedMultResultName(), {RiaDefines::combinedMultResultName(),
{RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX" ), {RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX-" ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY" ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY-" ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ" ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ-" )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" )}},
{RiaDefines::combinedRiTranResultName(), {RiaDefines::combinedRiTranResultName(),
{RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName() ), {RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranXResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName() ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranYResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName() )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranZResultName() )}},
{RiaDefines::combinedRiMultResultName(), {RiaDefines::combinedRiMultResultName(),
{RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riMultXResultName() ), {RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultXResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riMultYResultName() ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultYResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riMultZResultName() )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultZResultName() )}},
{RiaDefines::combinedRiAreaNormTranResultName(), {RiaDefines::combinedRiAreaNormTranResultName(),
{RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName() ), {RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName() ), RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName() ),
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName() )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName() )}},
{RiaDefines::combinedWaterFluxResultName(), {RiaDefines::combinedWaterFluxResultName(),
{RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATI+" ), {RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+" ), RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATK+" )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" )}},
{RiaDefines::combinedOilFluxResultName(), {RiaDefines::combinedOilFluxResultName(),
{RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILI+" ), {RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILJ+" ), RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILK+" )}}, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" )}},
{RiaDefines::combinedGasFluxResultName(), {RiaDefines::combinedGasFluxResultName(),
{RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASI+" ), {RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+" ), RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ),
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASK+" )}}}; RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" )}}};
auto resNameResultAddrsPairIt = resultsWithMultiPropertySource.find( resultName ); auto resNameResultAddrsPairIt = resultsWithMultiPropertySource.find( resultName );
@ -1296,7 +1296,7 @@ std::vector<RigEclipseResultAddress> sourcesForMultiPropertyResults( const QStri
for ( QString ending : endings ) for ( QString ending : endings )
{ {
resultAddrs.emplace_back( RigEclipseResultAddress( RiaDefines::GENERATED, baseName + ending ) ); resultAddrs.emplace_back( RigEclipseResultAddress( RiaDefines::ResultCatType::GENERATED, baseName + ending ) );
} }
return resultAddrs; return resultAddrs;

5
ApplicationCode/ProjectDataModel/Rim3dWellLogExtractionCurve.cpp
View File

@ -322,7 +322,8 @@ QString Rim3dWellLogExtractionCurve::createAutoName() const
if ( eclipseCase ) if ( eclipseCase )
{ {
addTimeStep = addTimeStep && m_eclipseResultDefinition->resultType() != RiaDefines::STATIC_NATIVE; addTimeStep = addTimeStep &&
m_eclipseResultDefinition->resultType() != RiaDefines::ResultCatType::STATIC_NATIVE;
RigEclipseCaseData* data = eclipseCase->eclipseCaseData(); RigEclipseCaseData* data = eclipseCase->eclipseCaseData();
if ( data ) if ( data )
{ {
@ -533,7 +534,7 @@ QString Rim3dWellLogExtractionCurve::wellDate() const
if ( eclipseCase ) if ( eclipseCase )
{ {
if ( m_eclipseResultDefinition->resultType() == RiaDefines::STATIC_NATIVE ) if ( m_eclipseResultDefinition->resultType() == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
return QString(); return QString();
} }

8
ApplicationCode/ProjectDataModel/RimAdvancedSnapshotExportDefinition.cpp
View File

@ -121,11 +121,11 @@ QList<caf::PdmOptionItemInfo>
else if ( fieldNeedingOptions == &eclipseResultType ) else if ( fieldNeedingOptions == &eclipseResultType )
{ {
options.push_back( options.push_back(
caf::PdmOptionItemInfo( caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::DYNAMIC_NATIVE ).uiText(), caf::PdmOptionItemInfo( caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::ResultCatType::DYNAMIC_NATIVE ).uiText(),
RiaDefines::DYNAMIC_NATIVE ) ); RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
options.push_back( options.push_back(
caf::PdmOptionItemInfo( caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::STATIC_NATIVE ).uiText(), caf::PdmOptionItemInfo( caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::ResultCatType::STATIC_NATIVE ).uiText(),
RiaDefines::STATIC_NATIVE ) ); RiaDefines::ResultCatType::STATIC_NATIVE ) );
} }
else if ( fieldNeedingOptions == &selectedEclipseResults ) else if ( fieldNeedingOptions == &selectedEclipseResults )
{ {

11
ApplicationCode/ProjectDataModel/RimCellEdgeColors.cpp
View File

@ -127,7 +127,7 @@ void RimCellEdgeColors::loadResult()
for ( i = 0; i < vars.size(); ++i ) for ( i = 0; i < vars.size(); ++i )
{ {
m_reservoirView->currentGridCellResults()->ensureKnownResultLoaded( m_reservoirView->currentGridCellResults()->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, vars[i] ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, vars[i] ) );
int cubeFaceIdx; int cubeFaceIdx;
for ( cubeFaceIdx = 0; cubeFaceIdx < 6; ++cubeFaceIdx ) for ( cubeFaceIdx = 0; cubeFaceIdx < 6; ++cubeFaceIdx )
{ {
@ -140,7 +140,8 @@ void RimCellEdgeColors::loadResult()
if ( vars[i].endsWith( varEnd ) ) if ( vars[i].endsWith( varEnd ) )
{ {
m_resultNameToAddressPairs[cubeFaceIdx] = m_resultNameToAddressPairs[cubeFaceIdx] =
std::make_pair( vars[i], RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, vars[i] ) ); std::make_pair( vars[i],
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, vars[i] ) );
} }
} }
} }
@ -202,7 +203,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions( const ca
if ( m_reservoirView && m_reservoirView->currentGridCellResults() ) if ( m_reservoirView && m_reservoirView->currentGridCellResults() )
{ {
QStringList varList; QStringList varList;
varList = m_reservoirView->currentGridCellResults()->resultNames( RiaDefines::STATIC_NATIVE ); varList = m_reservoirView->currentGridCellResults()->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
// TODO: Must also handle input properties // TODO: Must also handle input properties
// varList += m_reservoirView->gridCellResults()->resultNames(RiaDefines::INPUT_PROPERTY); // varList += m_reservoirView->gridCellResults()->resultNames(RiaDefines::INPUT_PROPERTY);
@ -310,7 +311,7 @@ QStringList RimCellEdgeColors::findResultVariableNames()
if ( m_reservoirView && m_reservoirView->currentGridCellResults() && !m_resultVariable().isEmpty() ) if ( m_reservoirView && m_reservoirView->currentGridCellResults() && !m_resultVariable().isEmpty() )
{ {
QStringList varList; QStringList varList;
varList = m_reservoirView->currentGridCellResults()->resultNames( RiaDefines::STATIC_NATIVE ); varList = m_reservoirView->currentGridCellResults()->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
// TODO: Must handle Input properties // TODO: Must handle Input properties
int i; int i;
@ -377,7 +378,7 @@ void RimCellEdgeColors::cellEdgeMetaData( std::vector<RimCellEdgeMetaData>* meta
bool isStatic = true; bool isStatic = true;
if ( isUsingSingleVariable() ) if ( isUsingSingleVariable() )
{ {
isStatic = m_singleVarEdgeResultColors->resultType() == RiaDefines::STATIC_NATIVE; isStatic = m_singleVarEdgeResultColors->resultType() == RiaDefines::ResultCatType::STATIC_NATIVE;
} }
for ( size_t i = 0; i < 6; i++ ) for ( size_t i = 0; i < 6; i++ )

16
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -303,7 +303,7 @@ RimEclipseView* RimEclipseCase::createAndAddReservoirView()
// Set default values // Set default values
{ {
rimEclipseView->cellResult()->setResultType( RiaDefines::DYNAMIC_NATIVE ); rimEclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
auto prefs = RiaApplication::instance()->preferences(); auto prefs = RiaApplication::instance()->preferences();
if ( prefs->loadAndShowSoil ) if ( prefs->loadAndShowSoil )
@ -528,7 +528,7 @@ void RimEclipseCase::updateFormationNamesData()
{ {
if ( !activeFormationNames() ) if ( !activeFormationNames() )
{ {
if ( eclView->cellResult()->resultType() == RiaDefines::FORMATION_NAMES ) if ( eclView->cellResult()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
eclView->cellResult()->setResultVariable( RiaDefines::undefinedResultName() ); eclView->cellResult()->setResultVariable( RiaDefines::undefinedResultName() );
eclView->cellResult()->updateConnectedEditors(); eclView->cellResult()->updateConnectedEditors();
@ -537,7 +537,7 @@ void RimEclipseCase::updateFormationNamesData()
RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection(); RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection();
for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters ) for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters )
{ {
if ( propFilter->resultDefinition()->resultType() == RiaDefines::FORMATION_NAMES ) if ( propFilter->resultDefinition()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
propFilter->resultDefinition()->setResultVariable( RiaDefines::undefinedResultName() ); propFilter->resultDefinition()->setResultVariable( RiaDefines::undefinedResultName() );
} }
@ -547,7 +547,7 @@ void RimEclipseCase::updateFormationNamesData()
RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection(); RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection();
for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters ) for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters )
{ {
if ( propFilter->resultDefinition()->resultType() == RiaDefines::FORMATION_NAMES ) if ( propFilter->resultDefinition()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
propFilter->setToDefaultValues(); propFilter->setToDefaultValues();
propFilter->updateConnectedEditors(); propFilter->updateConnectedEditors();
@ -892,7 +892,7 @@ bool RimEclipseCase::openReserviorCase()
// After the placeholder result for combined transmissibility is created, // After the placeholder result for combined transmissibility is created,
// make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well // make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well
RigEclipseResultAddress combinedTransmissibilityResAddr( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress combinedTransmissibilityResAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::combinedTransmissibilityResultName() ); RiaDefines::combinedTransmissibilityResultName() );
if ( results->hasResultEntry( combinedTransmissibilityResAddr ) ) if ( results->hasResultEntry( combinedTransmissibilityResAddr ) )
{ {
@ -900,7 +900,7 @@ bool RimEclipseCase::openReserviorCase()
combinedTransmissibilityResAddr ); combinedTransmissibilityResAddr );
} }
RigEclipseResultAddress combinedWaterFluxResAddr( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress combinedWaterFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedWaterFluxResultName() ); RiaDefines::combinedWaterFluxResultName() );
if ( results->hasResultEntry( combinedWaterFluxResAddr ) ) if ( results->hasResultEntry( combinedWaterFluxResAddr ) )
{ {
@ -908,14 +908,14 @@ bool RimEclipseCase::openReserviorCase()
combinedWaterFluxResAddr ); combinedWaterFluxResAddr );
} }
RigEclipseResultAddress combinedOilFluxResAddr( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress combinedOilFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedOilFluxResultName() ); RiaDefines::combinedOilFluxResultName() );
if ( results->hasResultEntry( combinedOilFluxResAddr ) ) if ( results->hasResultEntry( combinedOilFluxResAddr ) )
{ {
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress( RiaDefines::propertyNameFluxOil(), eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress( RiaDefines::propertyNameFluxOil(),
combinedOilFluxResAddr ); combinedOilFluxResAddr );
} }
RigEclipseResultAddress combinedGasFluxResAddr( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress combinedGasFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedGasFluxResultName() ); RiaDefines::combinedGasFluxResultName() );
if ( results->hasResultEntry( combinedGasFluxResAddr ) ) if ( results->hasResultEntry( combinedGasFluxResAddr ) )

37
ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

@ -184,18 +184,21 @@ std::vector<double> RimEclipseContourMapProjection::generateResults( int timeSte
if ( isColumnResult() ) if ( isColumnResult() )
{ {
m_currentResultName = ""; m_currentResultName = "";
resultData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ) ); resultData->ensureKnownResultLoaded(
resultData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ) );
resultData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); resultData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
resultData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
if ( m_resultAggregation == RESULTS_OIL_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN ) if ( m_resultAggregation == RESULTS_OIL_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN )
{ {
resultData->ensureKnownResultLoadedForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, resultData->ensureKnownResultLoadedForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL" ), "SOIL" ),
timeStep ); timeStep );
} }
if ( m_resultAggregation == RESULTS_GAS_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN ) if ( m_resultAggregation == RESULTS_GAS_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN )
{ {
resultData->ensureKnownResultLoadedForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, resultData->ensureKnownResultLoadedForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS" ), "SGAS" ),
timeStep ); timeStep );
} }
@ -258,9 +261,12 @@ void RimEclipseContourMapProjection::clearResultVariable()
std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( ResultAggregation resultAggregation ) const std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( ResultAggregation resultAggregation ) const
{ {
const RigCaseCellResultsData* resultData = eclipseCase()->results( RiaDefines::MATRIX_MODEL ); const RigCaseCellResultsData* resultData = eclipseCase()->results( RiaDefines::MATRIX_MODEL );
bool hasPoroResult = resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ) ); bool hasPoroResult =
bool hasNtgResult = resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ) );
bool hasDzResult = resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); bool hasNtgResult =
resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
bool hasDzResult =
resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
if ( !( hasPoroResult && hasNtgResult && hasDzResult ) ) if ( !( hasPoroResult && hasNtgResult && hasDzResult ) )
{ {
@ -268,11 +274,11 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( Resul
} }
const std::vector<double>& poroResults = const std::vector<double>& poroResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ), 0 ); resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ), 0 );
const std::vector<double>& ntgResults = const std::vector<double>& ntgResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ), 0 ); resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ), 0 );
const std::vector<double>& dzResults = const std::vector<double>& dzResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ), 0 ); resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ), 0 );
CVF_ASSERT( poroResults.size() == ntgResults.size() && ntgResults.size() == dzResults.size() ); CVF_ASSERT( poroResults.size() == ntgResults.size() && ntgResults.size() == dzResults.size() );
@ -283,7 +289,8 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( Resul
if ( resultAggregation == RESULTS_OIL_COLUMN || resultAggregation == RESULTS_HC_COLUMN ) if ( resultAggregation == RESULTS_OIL_COLUMN || resultAggregation == RESULTS_HC_COLUMN )
{ {
const std::vector<double>& soilResults = const std::vector<double>& soilResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ), timeStep ); resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ),
timeStep );
for ( size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx ) for ( size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx )
{ {
resultValues[cellResultIdx] = soilResults[cellResultIdx]; resultValues[cellResultIdx] = soilResults[cellResultIdx];
@ -292,11 +299,13 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( Resul
if ( resultAggregation == RESULTS_GAS_COLUMN || resultAggregation == RESULTS_HC_COLUMN ) if ( resultAggregation == RESULTS_GAS_COLUMN || resultAggregation == RESULTS_HC_COLUMN )
{ {
bool hasGasResult = resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ); bool hasGasResult =
resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
if ( hasGasResult ) if ( hasGasResult )
{ {
const std::vector<double>& sgasResults = const std::vector<double>& sgasResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ), timeStep ); resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ),
timeStep );
for ( size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx ) for ( size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx )
{ {
resultValues[cellResultIdx] += sgasResults[cellResultIdx]; resultValues[cellResultIdx] += sgasResults[cellResultIdx];

4
ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
View File

@ -94,7 +94,7 @@ void RimEclipseInputProperty::fieldChangedByUi( const caf::PdmFieldHandle* chang
RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL );
if ( matrixResults ) if ( matrixResults )
{ {
if ( matrixResults->updateResultName( RiaDefines::INPUT_PROPERTY, oldName, newName ) ) if ( matrixResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) )
{ {
anyNameUpdated = true; anyNameUpdated = true;
} }
@ -103,7 +103,7 @@ void RimEclipseInputProperty::fieldChangedByUi( const caf::PdmFieldHandle* chang
RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL );
if ( fracResults ) if ( fracResults )
{ {
if ( fracResults->updateResultName( RiaDefines::INPUT_PROPERTY, oldName, newName ) ) if ( fracResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) )
{ {
anyNameUpdated = true; anyNameUpdated = true;
} }

2
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@ -400,7 +400,7 @@ void RimEclipsePropertyFilter::computeResultValueRange()
if ( m_resultDefinition->hasCategoryResult() ) if ( m_resultDefinition->hasCategoryResult() )
{ {
if ( m_resultDefinition->resultType() == RiaDefines::FORMATION_NAMES ) if ( m_resultDefinition->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
CVF_ASSERT( parentContainer()->reservoirView()->eclipseCase()->eclipseCaseData() ); CVF_ASSERT( parentContainer()->reservoirView()->eclipseCase()->eclipseCaseData() );

3
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilterCollection.cpp
View File

@ -125,7 +125,8 @@ bool RimEclipsePropertyFilterCollection::isUsingFormationNames() const
for ( RimEclipsePropertyFilter* propertyFilter : propertyFilters ) for ( RimEclipsePropertyFilter* propertyFilter : propertyFilters )
{ {
if ( propertyFilter->isActive() && propertyFilter->resultDefinition()->resultType() == RiaDefines::FORMATION_NAMES && if ( propertyFilter->isActive() &&
propertyFilter->resultDefinition()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES &&
propertyFilter->resultDefinition()->resultVariable() != RiaDefines::undefinedResultName() ) propertyFilter->resultDefinition()->resultVariable() != RiaDefines::undefinedResultName() )
return true; return true;
} }

4
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -330,9 +330,9 @@ void RimEclipseResultCase::loadAndUpdateSourSimData()
RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( view ); RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( view );
if ( eclipseView != nullptr ) if ( eclipseView != nullptr )
{ {
if ( eclipseView->cellResult()->resultType() == RiaDefines::SOURSIMRL ) if ( eclipseView->cellResult()->resultType() == RiaDefines::ResultCatType::SOURSIMRL )
{ {
eclipseView->cellResult()->setResultType( RiaDefines::DYNAMIC_NATIVE ); eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
eclipseView->cellResult()->setResultVariable( "SOIL" ); eclipseView->cellResult()->setResultVariable( "SOIL" );
eclipseView->loadDataAndUpdate(); eclipseView->loadDataAndUpdate();
} }

90
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -275,7 +275,7 @@ void RimEclipseResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
QStringList varList = getResultNamesForResultType( m_resultTypeUiField(), this->currentGridCellResults() ); QStringList varList = getResultNamesForResultType( m_resultTypeUiField(), this->currentGridCellResults() );
bool isFlowDiagFieldsRelevant = ( m_resultType() == RiaDefines::FLOW_DIAGNOSTICS ); bool isFlowDiagFieldsRelevant = ( m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS );
if ( ( m_flowSolutionUiField() == m_flowSolution() || !isFlowDiagFieldsRelevant ) && if ( ( m_flowSolutionUiField() == m_flowSolution() || !isFlowDiagFieldsRelevant ) &&
m_resultTypeUiField() == m_resultType() && m_porosityModelUiField() == m_porosityModel() ) m_resultTypeUiField() == m_resultType() && m_porosityModelUiField() == m_porosityModel() )
@ -310,17 +310,17 @@ void RimEclipseResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
m_resultType = m_resultTypeUiField; m_resultType = m_resultTypeUiField;
m_resultVariable = m_resultVariableUiField; m_resultVariable = m_resultVariableUiField;
if ( m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
m_flowSolution = m_flowSolutionUiField(); m_flowSolution = m_flowSolutionUiField();
m_selectedInjectorTracers = m_selectedInjectorTracersUiField(); m_selectedInjectorTracers = m_selectedInjectorTracersUiField();
m_selectedProducerTracers = m_selectedProducerTracersUiField(); m_selectedProducerTracers = m_selectedProducerTracersUiField();
} }
else if ( m_resultTypeUiField() == RiaDefines::INJECTION_FLOODING ) else if ( m_resultTypeUiField() == RiaDefines::ResultCatType::INJECTION_FLOODING )
{ {
m_selectedSouringTracers = m_selectedSouringTracersUiField(); m_selectedSouringTracers = m_selectedSouringTracersUiField();
} }
else if ( m_resultTypeUiField() == RiaDefines::INPUT_PROPERTY ) else if ( m_resultTypeUiField() == RiaDefines::ResultCatType::INPUT_PROPERTY )
{ {
m_inputPropertyFileName = getInputPropertyFileName( newValue.toString() ); m_inputPropertyFileName = getInputPropertyFileName( newValue.toString() );
} }
@ -508,7 +508,7 @@ void RimEclipseResultDefinition::updateAnyFieldHasChanged()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEclipseResultDefinition::setTofAndSelectTracer( const QString& tracerName ) void RimEclipseResultDefinition::setTofAndSelectTracer( const QString& tracerName )
{ {
setResultType( RiaDefines::FLOW_DIAGNOSTICS ); setResultType( RiaDefines::ResultCatType::FLOW_DIAGNOSTICS );
setResultVariable( "TOF" ); setResultVariable( "TOF" );
setFlowDiagTracerSelectionType( FLOW_TR_BY_SELECTION ); setFlowDiagTracerSelectionType( FLOW_TR_BY_SELECTION );
@ -676,24 +676,24 @@ QList<caf::PdmOptionItemInfo>
// Do not include flow diagnostics results if it is a time history curve // Do not include flow diagnostics results if it is a time history curve
if ( resType == RiaDefines::FLOW_DIAGNOSTICS && ( timeHistoryCurve ) ) if ( resType == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS && ( timeHistoryCurve ) )
{ {
continue; continue;
} }
// Do not include SourSimRL if no SourSim file is loaded // Do not include SourSimRL if no SourSim file is loaded
if ( resType == RiaDefines::SOURSIMRL && ( !hasSourSimRLFile ) ) if ( resType == RiaDefines::ResultCatType::SOURSIMRL && ( !hasSourSimRLFile ) )
{ {
continue; continue;
} }
if ( resType == RiaDefines::INJECTION_FLOODING && !enableSouring ) if ( resType == RiaDefines::ResultCatType::INJECTION_FLOODING && !enableSouring )
{ {
continue; continue;
} }
if ( resType == RiaDefines::ALLEN_DIAGRAMS && !isSeparateFaultResult ) if ( resType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS && !isSeparateFaultResult )
{ {
continue; continue;
} }
@ -703,7 +703,7 @@ QList<caf::PdmOptionItemInfo>
} }
} }
if ( m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
if ( fieldNeedingOptions == &m_resultVariableUiField ) if ( fieldNeedingOptions == &m_resultVariableUiField )
{ {
@ -738,14 +738,15 @@ QList<caf::PdmOptionItemInfo>
options = calcOptionsForSelectedTracerField( false ); options = calcOptionsForSelectedTracerField( false );
} }
} }
else if ( m_resultTypeUiField() == RiaDefines::INJECTION_FLOODING ) else if ( m_resultTypeUiField() == RiaDefines::ResultCatType::INJECTION_FLOODING )
{ {
if ( fieldNeedingOptions == &m_selectedSouringTracersUiField ) if ( fieldNeedingOptions == &m_selectedSouringTracersUiField )
{ {
RigCaseCellResultsData* cellResultsStorage = currentGridCellResults(); RigCaseCellResultsData* cellResultsStorage = currentGridCellResults();
if ( cellResultsStorage ) if ( cellResultsStorage )
{ {
QStringList dynamicResultNames = cellResultsStorage->resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList dynamicResultNames =
cellResultsStorage->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
for ( const QString& resultName : dynamicResultNames ) for ( const QString& resultName : dynamicResultNames )
{ {
@ -900,7 +901,7 @@ RigFlowDiagResultAddress RimEclipseResultDefinition::flowDiagResAddress() const
{ {
CVF_ASSERT( isFlowDiagOrInjectionFlooding() ); CVF_ASSERT( isFlowDiagOrInjectionFlooding() );
if ( m_resultType() == RiaDefines::FLOW_DIAGNOSTICS ) if ( m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
size_t timeStep = 0; size_t timeStep = 0;
@ -998,7 +999,7 @@ void RimEclipseResultDefinition::setFlowDiagTracerSelectionType( FlowTracerSelec
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QString RimEclipseResultDefinition::resultVariableUiName() const QString RimEclipseResultDefinition::resultVariableUiName() const
{ {
if ( resultType() == RiaDefines::FLOW_DIAGNOSTICS ) if ( resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
return flowDiagResUiText( false, 32 ); return flowDiagResUiText( false, 32 );
} }
@ -1011,7 +1012,7 @@ QString RimEclipseResultDefinition::resultVariableUiName() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QString RimEclipseResultDefinition::resultVariableUiShortName() const QString RimEclipseResultDefinition::resultVariableUiShortName() const
{ {
if ( resultType() == RiaDefines::FLOW_DIAGNOSTICS ) if ( resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
return flowDiagResUiText( true, 24 ); return flowDiagResUiText( true, 24 );
} }
@ -1193,19 +1194,19 @@ bool RimEclipseResultDefinition::hasDynamicResult() const
{ {
if ( hasResult() ) if ( hasResult() )
{ {
if ( m_resultType() == RiaDefines::DYNAMIC_NATIVE ) if ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
{ {
return true; return true;
} }
else if ( m_resultType() == RiaDefines::SOURSIMRL ) else if ( m_resultType() == RiaDefines::ResultCatType::SOURSIMRL )
{ {
return true; return true;
} }
else if ( m_resultType() == RiaDefines::FLOW_DIAGNOSTICS ) else if ( m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
return true; return true;
} }
else if ( m_resultType() == RiaDefines::INJECTION_FLOODING ) else if ( m_resultType() == RiaDefines::ResultCatType::INJECTION_FLOODING )
{ {
return true; return true;
} }
@ -1376,7 +1377,7 @@ void RimEclipseResultDefinition::setDiffResultOptionsEnabled( bool enabled )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::isTernarySaturationSelected() const bool RimEclipseResultDefinition::isTernarySaturationSelected() const
{ {
bool isTernary = ( m_resultType() == RiaDefines::DYNAMIC_NATIVE ) && bool isTernary = ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) &&
( m_resultVariable().compare( RiaDefines::ternarySaturationResultName(), Qt::CaseInsensitive ) == 0 ); ( m_resultVariable().compare( RiaDefines::ternarySaturationResultName(), Qt::CaseInsensitive ) == 0 );
return isTernary; return isTernary;
@ -1387,7 +1388,8 @@ bool RimEclipseResultDefinition::isTernarySaturationSelected() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::isCompletionTypeSelected() const bool RimEclipseResultDefinition::isCompletionTypeSelected() const
{ {
return ( m_resultType() == RiaDefines::DYNAMIC_NATIVE && m_resultVariable() == RiaDefines::completionTypeResultName() ); return ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
m_resultVariable() == RiaDefines::completionTypeResultName() );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -1395,15 +1397,16 @@ bool RimEclipseResultDefinition::isCompletionTypeSelected() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::hasCategoryResult() const bool RimEclipseResultDefinition::hasCategoryResult() const
{ {
if ( this->m_resultType() == RiaDefines::FORMATION_NAMES && m_eclipseCase && m_eclipseCase->eclipseCaseData() && if ( this->m_resultType() == RiaDefines::ResultCatType::FORMATION_NAMES && m_eclipseCase &&
m_eclipseCase->eclipseCaseData()->activeFormationNames() ) m_eclipseCase->eclipseCaseData() && m_eclipseCase->eclipseCaseData()->activeFormationNames() )
return true; return true;
if ( this->m_resultType() == RiaDefines::DYNAMIC_NATIVE && if ( this->m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
this->resultVariable() == RiaDefines::completionTypeResultName() ) this->resultVariable() == RiaDefines::completionTypeResultName() )
return true; return true;
if ( this->m_resultType() == RiaDefines::FLOW_DIAGNOSTICS && m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME ) if ( this->m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS &&
m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
return true; return true;
if ( this->resultVariable() == RiaDefines::formationAllenResultName() || if ( this->resultVariable() == RiaDefines::formationAllenResultName() ||
@ -1422,7 +1425,8 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::isFlowDiagOrInjectionFlooding() const bool RimEclipseResultDefinition::isFlowDiagOrInjectionFlooding() const
{ {
if ( this->m_resultType() == RiaDefines::FLOW_DIAGNOSTICS || this->m_resultType() == RiaDefines::INJECTION_FLOODING ) if ( this->m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS ||
this->m_resultType() == RiaDefines::ResultCatType::INJECTION_FLOODING )
{ {
return true; return true;
} }
@ -1442,7 +1446,7 @@ void RimEclipseResultDefinition::defineUiOrdering( QString uiConfigName, caf::Pd
uiOrdering.add( &m_porosityModelUiField ); uiOrdering.add( &m_porosityModelUiField );
} }
if ( m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
uiOrdering.add( &m_flowSolutionUiField ); uiOrdering.add( &m_flowSolutionUiField );
@ -1470,13 +1474,13 @@ void RimEclipseResultDefinition::defineUiOrdering( QString uiConfigName, caf::Pd
} }
} }
if ( m_resultTypeUiField() == RiaDefines::INJECTION_FLOODING ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::INJECTION_FLOODING )
{ {
uiOrdering.add( &m_selectedSouringTracersUiField ); uiOrdering.add( &m_selectedSouringTracersUiField );
} }
uiOrdering.add( &m_resultVariableUiField ); uiOrdering.add( &m_resultVariableUiField );
if ( m_resultTypeUiField() == RiaDefines::INPUT_PROPERTY ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::INPUT_PROPERTY )
{ {
uiOrdering.add( &m_inputPropertyFileName ); uiOrdering.add( &m_inputPropertyFileName );
} }
@ -1510,7 +1514,7 @@ void RimEclipseResultDefinition::defineEditorAttribute( const caf::PdmFieldHandl
QString uiConfigName, QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) caf::PdmUiEditorAttribute* attribute )
{ {
if ( m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS ) if ( m_resultTypeUiField() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
if ( field == &m_resultVariableUiField ) if ( field == &m_resultVariableUiField )
{ {
@ -1637,7 +1641,8 @@ QList<caf::PdmOptionItemInfo>
bool addPerCellFaceOptionItems, bool addPerCellFaceOptionItems,
bool ternaryEnabled ) bool ternaryEnabled )
{ {
CVF_ASSERT( resultCatType != RiaDefines::FLOW_DIAGNOSTICS && resultCatType != RiaDefines::INJECTION_FLOODING ); CVF_ASSERT( resultCatType != RiaDefines::ResultCatType::FLOW_DIAGNOSTICS &&
resultCatType != RiaDefines::ResultCatType::INJECTION_FLOODING );
if ( results ) if ( results )
{ {
@ -1697,7 +1702,7 @@ QList<caf::PdmOptionItemInfo>
else if ( cellCenterResultNames.contains( "SWAT" ) ) else if ( cellCenterResultNames.contains( "SWAT" ) )
hasAtLeastOneTernaryComponent = true; hasAtLeastOneTernaryComponent = true;
if ( resultCatType == RiaDefines::DYNAMIC_NATIVE && hasAtLeastOneTernaryComponent ) if ( resultCatType == RiaDefines::ResultCatType::DYNAMIC_NATIVE && hasAtLeastOneTernaryComponent )
{ {
optionList.push_front( caf::PdmOptionItemInfo( RiaDefines::ternarySaturationResultName(), optionList.push_front( caf::PdmOptionItemInfo( RiaDefines::ternarySaturationResultName(),
RiaDefines::ternarySaturationResultName() ) ); RiaDefines::ternarySaturationResultName() ) );
@ -1886,12 +1891,12 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
if ( this->hasCategoryResult() ) if ( this->hasCategoryResult() )
{ {
if ( this->resultType() == RiaDefines::FORMATION_NAMES ) if ( this->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
std::vector<QString> fnVector = eclipseCaseData->formationNames(); std::vector<QString> fnVector = eclipseCaseData->formationNames();
legendConfigToUpdate->setNamedCategoriesInverse( fnVector ); legendConfigToUpdate->setNamedCategoriesInverse( fnVector );
} }
else if ( this->resultType() == RiaDefines::ALLEN_DIAGRAMS ) else if ( this->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
if ( this->resultVariable() == RiaDefines::formationAllenResultName() ) if ( this->resultVariable() == RiaDefines::formationAllenResultName() )
{ {
@ -1946,7 +1951,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
legendConfigToUpdate->setCategoryItems( categories ); legendConfigToUpdate->setCategoryItems( categories );
} }
} }
else if ( this->resultType() == RiaDefines::DYNAMIC_NATIVE && else if ( this->resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
this->resultVariable() == RiaDefines::completionTypeResultName() ) this->resultVariable() == RiaDefines::completionTypeResultName() )
{ {
const std::vector<int>& visibleCategories = const std::vector<int>& visibleCategories =
@ -1998,7 +2003,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
{ {
RigCaseCellResultsData* gridCellResults = this->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, "SOIL" ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" );
if ( gridCellResults->ensureKnownResultLoaded( resAddr ) ) if ( gridCellResults->ensureKnownResultLoaded( resAddr ) )
{ {
@ -2019,7 +2024,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
} }
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, "SGAS" ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" );
if ( gridCellResults->ensureKnownResultLoaded( resAddr ) ) if ( gridCellResults->ensureKnownResultLoaded( resAddr ) )
{ {
@ -2040,7 +2045,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
} }
{ {
RigEclipseResultAddress resAddr( RiaDefines::DYNAMIC_NATIVE, "SWAT" ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" );
if ( gridCellResults->ensureKnownResultLoaded( resAddr ) ) if ( gridCellResults->ensureKnownResultLoaded( resAddr ) )
{ {
@ -2243,7 +2248,7 @@ QString RimEclipseResultDefinition::selectedTracersString() const
QStringList RimEclipseResultDefinition::getResultNamesForResultType( RiaDefines::ResultCatType resultCatType, QStringList RimEclipseResultDefinition::getResultNamesForResultType( RiaDefines::ResultCatType resultCatType,
const RigCaseCellResultsData* results ) const RigCaseCellResultsData* results )
{ {
if ( resultCatType != RiaDefines::FLOW_DIAGNOSTICS ) if ( resultCatType != RiaDefines::ResultCatType::FLOW_DIAGNOSTICS )
{ {
if ( !results ) return QStringList(); if ( !results ) return QStringList();
@ -2462,7 +2467,7 @@ bool RimEclipseResultDefinition::enableDiffResultOptions() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::isTimeDiffResultAvailable() const bool RimEclipseResultDefinition::isTimeDiffResultAvailable() const
{ {
return enableDiffResultOptions() && m_resultTypeUiField() == RiaDefines::DYNAMIC_NATIVE && return enableDiffResultOptions() && m_resultTypeUiField() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
!isTernarySaturationSelected(); !isTernarySaturationSelected();
} }
@ -2480,8 +2485,9 @@ bool RimEclipseResultDefinition::isTimeDiffResult() const
bool RimEclipseResultDefinition::isCaseDiffResultAvailable() const bool RimEclipseResultDefinition::isCaseDiffResultAvailable() const
{ {
return enableDiffResultOptions() && !isTernarySaturationSelected() && return enableDiffResultOptions() && !isTernarySaturationSelected() &&
( m_resultTypeUiField() == RiaDefines::DYNAMIC_NATIVE || ( m_resultTypeUiField() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ||
m_resultTypeUiField() == RiaDefines::STATIC_NATIVE || m_resultTypeUiField() == RiaDefines::GENERATED ); m_resultTypeUiField() == RiaDefines::ResultCatType::STATIC_NATIVE ||
m_resultTypeUiField() == RiaDefines::ResultCatType::GENERATED );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

76
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -295,28 +295,28 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedDynamicProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedDynamicProperties().size(); ++pIdx )
{ {
resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL, resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
m_selectedDynamicProperties()[pIdx] ) ); m_selectedDynamicProperties()[pIdx] ) );
} }
for ( size_t pIdx = 0; pIdx < m_selectedStaticProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedStaticProperties().size(); ++pIdx )
{ {
resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL, resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL,
RiaDefines::STATIC_NATIVE, RiaDefines::ResultCatType::STATIC_NATIVE,
m_selectedStaticProperties()[pIdx] ) ); m_selectedStaticProperties()[pIdx] ) );
} }
for ( size_t pIdx = 0; pIdx < m_selectedGeneratedProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedGeneratedProperties().size(); ++pIdx )
{ {
resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL, resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL,
RiaDefines::GENERATED, RiaDefines::ResultCatType::GENERATED,
m_selectedGeneratedProperties()[pIdx] ) ); m_selectedGeneratedProperties()[pIdx] ) );
} }
for ( size_t pIdx = 0; pIdx < m_selectedInputProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedInputProperties().size(); ++pIdx )
{ {
resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL, resultSpecification.append( RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::MATRIX_MODEL,
RiaDefines::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
m_selectedInputProperties()[pIdx] ) ); m_selectedInputProperties()[pIdx] ) );
} }
@ -324,7 +324,7 @@ void RimEclipseStatisticsCase::computeStatistics()
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
m_selectedFractureDynamicProperties()[pIdx] ) ); m_selectedFractureDynamicProperties()[pIdx] ) );
} }
@ -332,7 +332,7 @@ void RimEclipseStatisticsCase::computeStatistics()
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RiaDefines::STATIC_NATIVE, RiaDefines::ResultCatType::STATIC_NATIVE,
m_selectedFractureStaticProperties()[pIdx] ) ); m_selectedFractureStaticProperties()[pIdx] ) );
} }
@ -340,7 +340,7 @@ void RimEclipseStatisticsCase::computeStatistics()
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RiaDefines::GENERATED, RiaDefines::ResultCatType::GENERATED,
m_selectedFractureGeneratedProperties()[pIdx] ) ); m_selectedFractureGeneratedProperties()[pIdx] ) );
} }
@ -348,7 +348,7 @@ void RimEclipseStatisticsCase::computeStatistics()
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RiaDefines::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
m_selectedFractureInputProperties()[pIdx] ) ); m_selectedFractureInputProperties()[pIdx] ) );
} }
@ -489,42 +489,50 @@ QList<caf::PdmOptionItemInfo>
if ( &m_selectedDynamicProperties == fieldNeedingOptions ) if ( &m_selectedDynamicProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedStaticProperties == fieldNeedingOptions ) else if ( &m_selectedStaticProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::STATIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedGeneratedProperties == fieldNeedingOptions ) else if ( &m_selectedGeneratedProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::GENERATED ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedInputProperties == fieldNeedingOptions ) else if ( &m_selectedInputProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::INPUT_PROPERTY ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureDynamicProperties == fieldNeedingOptions ) else if ( &m_selectedFractureDynamicProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureStaticProperties == fieldNeedingOptions ) else if ( &m_selectedFractureStaticProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::STATIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureGeneratedProperties == fieldNeedingOptions ) else if ( &m_selectedFractureGeneratedProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::GENERATED ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureInputProperties == fieldNeedingOptions ) else if ( &m_selectedFractureInputProperties == fieldNeedingOptions )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::INPUT_PROPERTY ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList ); return toOptionList( varList );
} }
@ -717,22 +725,30 @@ void RimEclipseStatisticsCase::updateSelectionListVisibilities()
// !caseGroup()->mainCase()->reservoirData()->results(RiaDefines::FRACTURE_MODEL)->resultCount() // !caseGroup()->mainCase()->reservoirData()->results(RiaDefines::FRACTURE_MODEL)->resultCount()
m_selectedDynamicProperties.uiCapability()->setUiHidden( m_selectedDynamicProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE ) ); isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedStaticProperties.uiCapability()->setUiHidden( m_selectedStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE ) ); isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedGeneratedProperties.uiCapability()->setUiHidden( m_selectedGeneratedProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::GENERATED ) ); isLocked ||
!( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedInputProperties.uiCapability()->setUiHidden( m_selectedInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::INPUT_PROPERTY ) ); isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
m_selectedFractureDynamicProperties.uiCapability()->setUiHidden( m_selectedFractureDynamicProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE ) ); isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedFractureStaticProperties.uiCapability()->setUiHidden( m_selectedFractureStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE ) ); isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden( m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::GENERATED ) ); isLocked ||
!( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedFractureInputProperties.uiCapability()->setUiHidden( m_selectedFractureInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::INPUT_PROPERTY ) ); isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -837,28 +853,32 @@ void RimEclipseStatisticsCase::populateResultSelection()
if ( m_selectedDynamicProperties().size() == 0 ) if ( m_selectedDynamicProperties().size() == 0 )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
if ( varList.contains( "SOIL" ) ) m_selectedDynamicProperties.v().push_back( "SOIL" ); if ( varList.contains( "SOIL" ) ) m_selectedDynamicProperties.v().push_back( "SOIL" );
if ( varList.contains( "PRESSURE" ) ) m_selectedDynamicProperties.v().push_back( "PRESSURE" ); if ( varList.contains( "PRESSURE" ) ) m_selectedDynamicProperties.v().push_back( "PRESSURE" );
} }
if ( m_selectedStaticProperties().size() == 0 ) if ( m_selectedStaticProperties().size() == 0 )
{ {
QStringList varList = caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::STATIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
if ( varList.contains( "PERMX" ) ) m_selectedStaticProperties.v().push_back( "PERMX" ); if ( varList.contains( "PERMX" ) ) m_selectedStaticProperties.v().push_back( "PERMX" );
if ( varList.contains( "PORO" ) ) m_selectedStaticProperties.v().push_back( "PORO" ); if ( varList.contains( "PORO" ) ) m_selectedStaticProperties.v().push_back( "PORO" );
} }
if ( m_selectedFractureDynamicProperties().size() == 0 ) if ( m_selectedFractureDynamicProperties().size() == 0 )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
if ( varList.contains( "SOIL" ) ) m_selectedFractureDynamicProperties.v().push_back( "SOIL" ); if ( varList.contains( "SOIL" ) ) m_selectedFractureDynamicProperties.v().push_back( "SOIL" );
if ( varList.contains( "PRESSURE" ) ) m_selectedFractureDynamicProperties.v().push_back( "PRESSURE" ); if ( varList.contains( "PRESSURE" ) ) m_selectedFractureDynamicProperties.v().push_back( "PRESSURE" );
} }
if ( m_selectedFractureStaticProperties().size() == 0 ) if ( m_selectedFractureStaticProperties().size() == 0 )
{ {
QStringList varList = caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::STATIC_NATIVE ); QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
if ( varList.contains( "PERMX" ) ) m_selectedFractureStaticProperties.v().push_back( "PERMX" ); if ( varList.contains( "PERMX" ) ) m_selectedFractureStaticProperties.v().push_back( "PERMX" );
if ( varList.contains( "PORO" ) ) m_selectedFractureStaticProperties.v().push_back( "PORO" ); if ( varList.contains( "PORO" ) ) m_selectedFractureStaticProperties.v().push_back( "PORO" );
} }

2
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -172,7 +172,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults( const QList<ResSpec>
size_t dataAccessTimeStepIndex = timeStepIdx; size_t dataAccessTimeStepIndex = timeStepIdx;
// Always evaluate statistics once, and always use time step index zero // Always evaluate statistics once, and always use time step index zero
if ( resultType == RiaDefines::STATIC_NATIVE ) if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
if ( timeIndicesIdx > 0 ) continue; if ( timeIndicesIdx > 0 ) continue;

2
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@ -62,7 +62,7 @@ public:
struct ResSpec struct ResSpec
{ {
ResSpec() ResSpec()
: m_resType( RiaDefines::DYNAMIC_NATIVE ) : m_resType( RiaDefines::ResultCatType::DYNAMIC_NATIVE )
, m_poroModel( RiaDefines::MATRIX_MODEL ) , m_poroModel( RiaDefines::MATRIX_MODEL )
{ {
} }

8
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -1346,7 +1346,8 @@ void RimEclipseView::onUpdateLegends()
if ( this->cellEdgeResult()->hasCategoryResult() ) if ( this->cellEdgeResult()->hasCategoryResult() )
{ {
if ( cellEdgeResult()->singleVarEdgeResultColors()->resultType() != RiaDefines::FORMATION_NAMES ) if ( cellEdgeResult()->singleVarEdgeResultColors()->resultType() !=
RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
cellEdgeResult()->legendConfig()->setIntegerCategories( results->uniqueCellScalarValues( cellEdgeResult()->legendConfig()->setIntegerCategories( results->uniqueCellScalarValues(
cellEdgeResult()->singleVarEdgeResultColors()->eclipseResultAddress() ) ); cellEdgeResult()->singleVarEdgeResultColors()->eclipseResultAddress() ) );
@ -2249,9 +2250,10 @@ void RimEclipseView::defineAxisLabels( cvf::String* xLabel, cvf::String* yLabel,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseView::isUsingFormationNames() const bool RimEclipseView::isUsingFormationNames() const
{ {
if ( cellResult()->resultType() == RiaDefines::FORMATION_NAMES ) return true; if ( cellResult()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES ) return true;
if ( faultResultSettings()->customFaultResult()->resultType() == RiaDefines::ALLEN_DIAGRAMS ) return true; if ( faultResultSettings()->customFaultResult()->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
return true;
return eclipsePropertyFilterCollection()->isUsingFormationNames(); return eclipsePropertyFilterCollection()->isUsingFormationNames();
} }

27
ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp
View File

@ -355,15 +355,18 @@ RigEclipseResultAddress RimElementVectorResult::resultAddressCombined() const
{ {
if ( resultName() == "Oil" ) if ( resultName() == "Oil" )
{ {
return RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName() ); return RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedOilFluxResultName() );
} }
else if ( resultName() == "Gas" ) else if ( resultName() == "Gas" )
{ {
return RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName() ); return RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedGasFluxResultName() );
} }
else if ( resultName() == "Water" ) else if ( resultName() == "Water" )
{ {
return RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName() ); return RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedWaterFluxResultName() );
} }
return RigEclipseResultAddress(); return RigEclipseResultAddress();
@ -379,23 +382,23 @@ bool RimElementVectorResult::resultAddressIJK( std::vector<RigEclipseResultAddre
// TODO: use enum?? // TODO: use enum??
if ( resultName() == "Oil" ) if ( resultName() == "Oil" )
{ {
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILI+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILJ+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILK+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" ) );
return true; return true;
} }
else if ( resultName() == "Gas" ) else if ( resultName() == "Gas" )
{ {
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASI+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASK+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" ) );
return true; return true;
} }
else if ( resultName() == "Water" ) else if ( resultName() == "Water" )
{ {
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATI+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ) );
addresses.push_back( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATK+" ) ); addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" ) );
return true; return true;
} }

2
ApplicationCode/ProjectDataModel/RimRegularLegendConfig.cpp
View File

@ -983,7 +983,7 @@ QList<caf::PdmOptionItemInfo>
isCategoryResult = true; isCategoryResult = true;
} }
if ( eclCellColors && eclCellColors->resultType() == RiaDefines::ALLEN_DIAGRAMS ) if ( eclCellColors && eclCellColors->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
isAllenDiagram = true; isAllenDiagram = true;
} }

2
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -321,7 +321,7 @@ RimReservoirCellResultsStorageEntryInfo::RimReservoirCellResultsStorageEntryInfo
CAF_PDM_InitField( &m_resultType, CAF_PDM_InitField( &m_resultType,
"ResultType", "ResultType",
caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::REMOVED ), caf::AppEnum<RiaDefines::ResultCatType>( RiaDefines::ResultCatType::REMOVED ),
"ResultType", "ResultType",
"", "",
"", "",

2
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -214,7 +214,7 @@ void RimWellLogExtractionCurve::setPropertiesFromView( Rim3dView* view )
} }
else if ( eclipseCase ) else if ( eclipseCase )
{ {
m_eclipseResultDefinition->setResultType( RiaDefines::STATIC_NATIVE ); m_eclipseResultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
m_eclipseResultDefinition->setResultVariable( "PORO" ); m_eclipseResultDefinition->setResultVariable( "PORO" );
} }

32
ApplicationCode/ProjectDataModel/RimWellLogTrack.cpp
View File

@ -1930,21 +1930,21 @@ std::vector<std::pair<double, double>> RimWellLogTrack::waterAndRockRegions( Ria
} }
double waterEndMD = extractor->cellIntersectionMDs().front(); double waterEndMD = extractor->cellIntersectionMDs().front();
double rockEndMD = extractor->cellIntersectionMDs().back(); double rockEndMD = extractor->cellIntersectionMDs().back();
return { { waterStartMD, waterEndMD }, { waterEndMD, rockEndMD } }; return {{waterStartMD, waterEndMD}, {waterEndMD, rockEndMD}};
} }
else if ( depthType == RiaDefines::TRUE_VERTICAL_DEPTH ) else if ( depthType == RiaDefines::TRUE_VERTICAL_DEPTH )
{ {
double waterStartTVD = 0.0; double waterStartTVD = 0.0;
double waterEndTVD = extractor->cellIntersectionTVDs().front(); double waterEndTVD = extractor->cellIntersectionTVDs().front();
double rockEndTVD = extractor->cellIntersectionTVDs().back(); double rockEndTVD = extractor->cellIntersectionTVDs().back();
return { { waterStartTVD, waterEndTVD }, { waterEndTVD, rockEndTVD } }; return {{waterStartTVD, waterEndTVD}, {waterEndTVD, rockEndTVD}};
} }
else if ( depthType == RiaDefines::TRUE_VERTICAL_DEPTH_RKB ) else if ( depthType == RiaDefines::TRUE_VERTICAL_DEPTH_RKB )
{ {
double waterStartTVDRKB = extractor->wellPathData()->rkbDiff(); double waterStartTVDRKB = extractor->wellPathData()->rkbDiff();
double waterEndTVDRKB = extractor->cellIntersectionTVDs().front() + extractor->wellPathData()->rkbDiff(); double waterEndTVDRKB = extractor->cellIntersectionTVDs().front() + extractor->wellPathData()->rkbDiff();
double rockEndTVDRKB = extractor->cellIntersectionTVDs().back() + extractor->wellPathData()->rkbDiff(); double rockEndTVDRKB = extractor->cellIntersectionTVDs().back() + extractor->wellPathData()->rkbDiff();
return { { waterStartTVDRKB, waterEndTVDRKB }, { waterEndTVDRKB, rockEndTVDRKB } }; return {{waterStartTVDRKB, waterEndTVDRKB}, {waterEndTVDRKB, rockEndTVDRKB}};
} }
return {}; return {};
} }
@ -2354,7 +2354,7 @@ void RimWellLogTrack::updateFormationNamesOnPlot()
0, 0,
RiaDefines::PorosityModelType::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::FORMATION_NAMES, RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName() ) ); RiaDefines::activeFormationNamesResultName() ) );
curveData = RimWellLogTrack::curveSamplingPointData( eclWellLogExtractor, resultAccessor.p() ); curveData = RimWellLogTrack::curveSamplingPointData( eclWellLogExtractor, resultAccessor.p() );
@ -2384,7 +2384,7 @@ void RimWellLogTrack::updateFormationNamesOnPlot()
const std::vector<std::pair<double, double>> waterAndRockIntervals = const std::vector<std::pair<double, double>> waterAndRockIntervals =
waterAndRockRegions( plot->depthType(), extractor ); waterAndRockRegions( plot->depthType(), extractor );
m_annotationTool->attachNamedRegions( m_plotWidget, m_annotationTool->attachNamedRegions( m_plotWidget,
{ "Sea Level", "" }, {"Sea Level", ""},
xRange, xRange,
waterAndRockIntervals, waterAndRockIntervals,
m_regionAnnotationDisplay(), m_regionAnnotationDisplay(),
@ -2392,7 +2392,7 @@ void RimWellLogTrack::updateFormationNamesOnPlot()
( ( 100 - m_colorShadingTransparency ) * 255 ) / 100, ( ( 100 - m_colorShadingTransparency ) * 255 ) / 100,
m_showRegionLabels(), m_showRegionLabels(),
RiuPlotAnnotationTool::LEFT_COLUMN, RiuPlotAnnotationTool::LEFT_COLUMN,
{ Qt::SolidPattern, Qt::Dense6Pattern } ); {Qt::SolidPattern, Qt::Dense6Pattern} );
} }
if ( m_formationSource == CASE ) if ( m_formationSource == CASE )
@ -2590,16 +2590,16 @@ void RimWellLogTrack::updateWellPathAttributesOnPlot()
} }
} }
const std::map<RiaDefines::WellPathComponentType, int> sortIndices = { { RiaDefines::WELL_PATH, 0 }, const std::map<RiaDefines::WellPathComponentType, int> sortIndices = {{RiaDefines::WELL_PATH, 0},
{ RiaDefines::CASING, 1 }, {RiaDefines::CASING, 1},
{ RiaDefines::LINER, 2 }, {RiaDefines::LINER, 2},
{ RiaDefines::PERFORATION_INTERVAL, 3 }, {RiaDefines::PERFORATION_INTERVAL, 3},
{ RiaDefines::FISHBONES, 4 }, {RiaDefines::FISHBONES, 4},
{ RiaDefines::FRACTURE, 5 }, {RiaDefines::FRACTURE, 5},
{ RiaDefines::PACKER, 6 }, {RiaDefines::PACKER, 6},
{ RiaDefines::ICD, 7 }, {RiaDefines::ICD, 7},
{ RiaDefines::AICD, 8 }, {RiaDefines::AICD, 8},
{ RiaDefines::ICV, 9 } }; {RiaDefines::ICV, 9}};
std::stable_sort( allWellPathComponents.begin(), std::stable_sort( allWellPathComponents.begin(),
allWellPathComponents.end(), allWellPathComponents.end(),

459
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -326,9 +326,12 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANX" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANY" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ) );
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANZ" ) ); calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
@ -336,12 +339,18 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX-" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ) );
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY-" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ) );
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ-" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
@ -349,13 +358,13 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riTranXResultName() ) ); RiaDefines::riTranXResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riTranYResultName() ) ); RiaDefines::riTranYResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riTranZResultName() ) ); RiaDefines::riTranZResultName() ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
@ -363,13 +372,13 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riMultXResultName() ) ); RiaDefines::riMultXResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riMultYResultName() ) ); RiaDefines::riMultYResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riMultZResultName() ) ); RiaDefines::riMultZResultName() ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
@ -377,38 +386,56 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranXResultName() ) ); RiaDefines::riAreaNormTranXResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranYResultName() ) ); RiaDefines::riAreaNormTranYResultName() ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranZResultName() ) ); RiaDefines::riAreaNormTranZResultName() ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else if ( resultName == RiaDefines::combinedWaterFluxResultName() ) else if ( resultName == RiaDefines::combinedWaterFluxResultName() )
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATI+" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATK+" ) ); "FLRWATI+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLRWATJ+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLRWATK+" ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else if ( resultName == RiaDefines::combinedOilFluxResultName() ) else if ( resultName == RiaDefines::combinedOilFluxResultName() )
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILI+" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILJ+" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILK+" ) ); "FLROILI+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLROILJ+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLROILK+" ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else if ( resultName == RiaDefines::combinedGasFluxResultName() ) else if ( resultName == RiaDefines::combinedGasFluxResultName() )
{ {
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASI+" ) ); calc->addNativeStatisticsCalculator( this,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
calc->addNativeStatisticsCalculator( this, RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASK+" ) ); "FLRGASI+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLRGASJ+" ) );
calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"FLRGASK+" ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else if ( resultName.endsWith( "IJK" ) ) else if ( resultName.endsWith( "IJK" ) )
@ -416,13 +443,13 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc(); cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
QString baseName = resultName.left( resultName.size() - 3 ); QString baseName = resultName.left( resultName.size() - 3 );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::GENERATED, RigEclipseResultAddress( RiaDefines::ResultCatType::GENERATED,
QString( "%1I" ).arg( baseName ) ) ); QString( "%1I" ).arg( baseName ) ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::GENERATED, RigEclipseResultAddress( RiaDefines::ResultCatType::GENERATED,
QString( "%1J" ).arg( baseName ) ) ); QString( "%1J" ).arg( baseName ) ) );
calc->addNativeStatisticsCalculator( this, calc->addNativeStatisticsCalculator( this,
RigEclipseResultAddress( RiaDefines::GENERATED, RigEclipseResultAddress( RiaDefines::ResultCatType::GENERATED,
QString( "%1K" ).arg( baseName ) ) ); QString( "%1K" ).arg( baseName ) ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
@ -514,7 +541,7 @@ bool RigCaseCellResultsData::isUsingGlobalActiveIndex( const RigEclipseResultAdd
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::hasFlowDiagUsableFluxes() const bool RigCaseCellResultsData::hasFlowDiagUsableFluxes() const
{ {
QStringList dynResVarNames = resultNames( RiaDefines::DYNAMIC_NATIVE ); QStringList dynResVarNames = resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
bool hasFlowFluxes = true; bool hasFlowFluxes = true;
hasFlowFluxes = dynResVarNames.contains( "FLRWATI+" ); hasFlowFluxes = dynResVarNames.contains( "FLRWATI+" );
@ -788,7 +815,7 @@ const std::vector<double>*
{ {
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); size_t resultCellCount = actCellInfo->reservoirCellResultCount();
size_t reservoirCellCount = actCellInfo->reservoirCellCount(); size_t reservoirCellCount = actCellInfo->reservoirCellCount();
RigEclipseResultAddress resVarAddr( RiaDefines::STATIC_NATIVE, resultName ); RigEclipseResultAddress resVarAddr( RiaDefines::ResultCatType::STATIC_NATIVE, resultName );
size_t scalarResultIndexPorv = gridCellResults->findOrLoadKnownScalarResult( resVarAddr ); size_t scalarResultIndexPorv = gridCellResults->findOrLoadKnownScalarResult( resVarAddr );
@ -866,9 +893,9 @@ void RigCaseCellResultsData::eraseAllSourSimData()
for ( size_t i = 0; i < m_resultInfos.size(); i++ ) for ( size_t i = 0; i < m_resultInfos.size(); i++ )
{ {
RigEclipseResultInfo& ri = m_resultInfos[i]; RigEclipseResultInfo& ri = m_resultInfos[i];
if ( ri.resultType() == RiaDefines::SOURSIMRL ) if ( ri.resultType() == RiaDefines::ResultCatType::SOURSIMRL )
{ {
ri.setResultType( RiaDefines::REMOVED ); ri.setResultType( RiaDefines::ResultCatType::REMOVED );
} }
} }
} }
@ -880,13 +907,15 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
// SOIL // SOIL
{ {
if ( !hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ) ) ) if ( !hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) ) )
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ) ) || if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) ) ||
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) ) )
{ {
size_t soilIndex = size_t soilIndex =
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ), false ); findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL" ),
false );
this->setMustBeCalculated( soilIndex ); this->setMustBeCalculated( soilIndex );
} }
} }
@ -895,9 +924,9 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
// Oil Volume // Oil Volume
if ( RiaApplication::enableDevelopmentFeatures() ) if ( RiaApplication::enableDevelopmentFeatures() )
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) ) )
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::riOilVolumeResultName() ), RiaDefines::riOilVolumeResultName() ),
false ); false );
} }
@ -905,47 +934,47 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
// Completion type // Completion type
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::completionTypeResultName() ), RiaDefines::completionTypeResultName() ),
false ); false );
} }
// Fault results // Fault results
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ALLEN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName() ), RiaDefines::formationBinaryAllenResultName() ),
false ); false );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ALLEN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationAllenResultName() ), RiaDefines::formationAllenResultName() ),
false ); false );
} }
// FLUX // FLUX
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATI+" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRWATK+" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" ) ) )
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedWaterFluxResultName() ), RiaDefines::combinedWaterFluxResultName() ),
false ); false );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILI+" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILJ+" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLROILK+" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" ) ) )
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedOilFluxResultName() ), RiaDefines::combinedOilFluxResultName() ),
false ); false );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASI+" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "FLRGASK+" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" ) ) )
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedGasFluxResultName() ), RiaDefines::combinedGasFluxResultName() ),
false ); false );
} }
@ -955,82 +984,100 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
if ( hasCompleteTransmissibilityResults() ) if ( hasCompleteTransmissibilityResults() )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::combinedTransmissibilityResultName(),
false,
0 );
} }
} }
// MULTXYZ // MULTXYZ
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTX-" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTY-" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "MULTZ-" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::combinedMultResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::combinedMultResultName(), false, 0 );
} }
} }
// riTRANSXYZ and X,Y,Z // riTRANSXYZ and X,Y,Z
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMX" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranXResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranYResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranZResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::combinedRiTranResultName(), false, 0 );
} }
} }
// riMULTXYZ and X, Y, Z // riMULTXYZ and X, Y, Z
{ {
if ( hasCompleteTransmissibilityResults() && if ( hasCompleteTransmissibilityResults() &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName() ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName() ) ) && RiaDefines::riTranXResultName() ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName() ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riTranYResultName() ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riTranZResultName() ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riMultXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultXResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riMultYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultYResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riMultZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultZResultName(), false, 0 );
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::combinedRiMultResultName(), false, 0 );
} }
} }
// riTRANSXYZbyArea and X, Y, Z // riTRANSXYZbyArea and X, Y, Z
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANX" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranXResultName(),
false,
0 );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANY" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranYResultName(),
false,
0 );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANZ" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riAreaNormTranZResultName(),
false,
0 );
} }
if ( hasCompleteTransmissibilityResults() ) if ( hasCompleteTransmissibilityResults() )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::combinedRiAreaNormTranResultName(),
false,
0 );
} }
} }
// Cell Volume // Cell Volume
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::riCellVolumeResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riCellVolumeResultName(), false, 0 );
} }
// Mobile Pore Volume // Mobile Pore Volume
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORV" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORV" ) ) )
{ {
addStaticScalarResult( RiaDefines::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName(), false, 0 );
} }
} }
} }
@ -1040,9 +1087,9 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::hasCompleteTransmissibilityResults() const bool RigCaseCellResultsData::hasCompleteTransmissibilityResults() const
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANX" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANY" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TRANZ" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) ) )
{ {
return true; return true;
} }
@ -1125,7 +1172,7 @@ void RigCaseCellResultsData::createResultEntry( const RigEclipseResultAddress& r
void RigCaseCellResultsData::ensureKnownResultLoadedForTimeStep( const RigEclipseResultAddress& resultAddress, void RigCaseCellResultsData::ensureKnownResultLoadedForTimeStep( const RigEclipseResultAddress& resultAddress,
size_t timeStepIndex ) size_t timeStepIndex )
{ {
CAF_ASSERT( resultAddress.m_resultCatType != RiaDefines::UNDEFINED ); CAF_ASSERT( resultAddress.m_resultCatType != RiaDefines::ResultCatType::UNDEFINED );
findOrLoadKnownScalarResultForTimeStep( resultAddress, timeStepIndex ); findOrLoadKnownScalarResultForTimeStep( resultAddress, timeStepIndex );
} }
@ -1139,14 +1186,14 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
{ {
return cvf::UNDEFINED_SIZE_T; return cvf::UNDEFINED_SIZE_T;
} }
else if ( resVarAddr.m_resultCatType == RiaDefines::UNDEFINED ) else if ( resVarAddr.m_resultCatType == RiaDefines::ResultCatType::UNDEFINED )
{ {
std::vector<RiaDefines::ResultCatType> searchOrder = {RiaDefines::STATIC_NATIVE, std::vector<RiaDefines::ResultCatType> searchOrder = {RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::SOURSIMRL, RiaDefines::ResultCatType::SOURSIMRL,
RiaDefines::GENERATED, RiaDefines::ResultCatType::GENERATED,
RiaDefines::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
RiaDefines::FORMATION_NAMES}; RiaDefines::ResultCatType::FORMATION_NAMES};
size_t scalarResultIndex = this->findOrLoadKnownScalarResultByResultTypeOrder( resVarAddr, searchOrder ); size_t scalarResultIndex = this->findOrLoadKnownScalarResultByResultTypeOrder( resVarAddr, searchOrder );
@ -1172,7 +1219,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
// Load dependency data sets // Load dependency data sets
if ( type == RiaDefines::STATIC_NATIVE ) if ( type == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
if ( resultName == RiaDefines::combinedTransmissibilityResultName() ) if ( resultName == RiaDefines::combinedTransmissibilityResultName() )
{ {
@ -1233,7 +1280,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
computeAllenResults( this, m_ownerMainGrid ); computeAllenResults( this, m_ownerMainGrid );
} }
} }
else if ( type == RiaDefines::DYNAMIC_NATIVE ) else if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
{ {
if ( resultName == RiaDefines::combinedWaterFluxResultName() ) if ( resultName == RiaDefines::combinedWaterFluxResultName() )
{ {
@ -1266,8 +1313,8 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
{ {
// Trigger loading of SWAT, SGAS to establish time step count if no data has been loaded from file at this // Trigger loading of SWAT, SGAS to establish time step count if no data has been loaded from file at this
// point // point
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
m_cellScalarResults[scalarResultIndex].resize( this->maxTimeStepCount() ); m_cellScalarResults[scalarResultIndex].resize( this->maxTimeStepCount() );
for ( size_t timeStepIdx = 0; timeStepIdx < this->maxTimeStepCount(); timeStepIdx++ ) for ( size_t timeStepIdx = 0; timeStepIdx < this->maxTimeStepCount(); timeStepIdx++ )
@ -1297,7 +1344,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
computeMobilePV(); computeMobilePV();
} }
if ( type == RiaDefines::GENERATED ) if ( type == RiaDefines::ResultCatType::GENERATED )
{ {
return cvf::UNDEFINED_SIZE_T; return cvf::UNDEFINED_SIZE_T;
} }
@ -1311,7 +1358,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
size_t tempGridCellCount = m_ownerMainGrid->totalTemporaryGridCellCount(); size_t tempGridCellCount = m_ownerMainGrid->totalTemporaryGridCellCount();
if ( type == RiaDefines::DYNAMIC_NATIVE && timeStepCount > 0 ) if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE && timeStepCount > 0 )
{ {
m_cellScalarResults[scalarResultIndex].resize( timeStepCount ); m_cellScalarResults[scalarResultIndex].resize( timeStepCount );
@ -1334,7 +1381,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
} }
} }
} }
else if ( type == RiaDefines::STATIC_NATIVE ) else if ( type == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
m_cellScalarResults[scalarResultIndex].resize( 1 ); m_cellScalarResults[scalarResultIndex].resize( 1 );
@ -1373,7 +1420,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
// Handle SourSimRL reading // Handle SourSimRL reading
if ( type == RiaDefines::SOURSIMRL ) if ( type == RiaDefines::ResultCatType::SOURSIMRL )
{ {
RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>( m_readerInterface.p() ); RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>( m_readerInterface.p() );
if ( eclReader ) if ( eclReader )
@ -1401,12 +1448,12 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultByResultTypeOrder(
const RigEclipseResultAddress& resVarAddr, const RigEclipseResultAddress& resVarAddr,
const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder ) const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
{ {
std::set<RiaDefines::ResultCatType> otherResultTypesToSearch = {RiaDefines::STATIC_NATIVE, std::set<RiaDefines::ResultCatType> otherResultTypesToSearch = {RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::SOURSIMRL, RiaDefines::ResultCatType::SOURSIMRL,
RiaDefines::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
RiaDefines::GENERATED, RiaDefines::ResultCatType::GENERATED,
RiaDefines::FORMATION_NAMES}; RiaDefines::ResultCatType::FORMATION_NAMES};
for ( const auto& resultType : resultCategorySearchOrder ) for ( const auto& resultType : resultCategorySearchOrder )
{ {
@ -1447,7 +1494,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
QString resultName = resVarAddr.m_resultName; QString resultName = resVarAddr.m_resultName;
// Special handling for SOIL // Special handling for SOIL
if ( type == RiaDefines::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL" ) if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL" )
{ {
size_t soilScalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr ); size_t soilScalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr );
@ -1464,7 +1511,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
return soilScalarResultIndex; return soilScalarResultIndex;
} }
} }
else if ( type == RiaDefines::DYNAMIC_NATIVE && resultName == RiaDefines::completionTypeResultName() ) else if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE && resultName == RiaDefines::completionTypeResultName() )
{ {
size_t completionTypeScalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr ); size_t completionTypeScalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr );
computeCompletionTypeForTimeStep( timeStepIndex ); computeCompletionTypeForTimeStep( timeStepIndex );
@ -1474,7 +1521,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
size_t scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr ); size_t scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddr );
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) return cvf::UNDEFINED_SIZE_T; if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) return cvf::UNDEFINED_SIZE_T;
if ( type == RiaDefines::GENERATED ) if ( type == RiaDefines::ResultCatType::GENERATED )
{ {
return cvf::UNDEFINED_SIZE_T; return cvf::UNDEFINED_SIZE_T;
} }
@ -1485,7 +1532,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
bool resultLoadingSucess = true; bool resultLoadingSucess = true;
if ( type == RiaDefines::DYNAMIC_NATIVE && timeStepCount > 0 ) if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE && timeStepCount > 0 )
{ {
m_cellScalarResults[scalarResultIndex].resize( timeStepCount ); m_cellScalarResults[scalarResultIndex].resize( timeStepCount );
@ -1498,7 +1545,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
} }
} }
} }
else if ( type == RiaDefines::STATIC_NATIVE ) else if ( type == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
m_cellScalarResults[scalarResultIndex].resize( 1 ); m_cellScalarResults[scalarResultIndex].resize( 1 );
@ -1518,7 +1565,7 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResultForTimeStep( const Rig
// Handle SourSimRL reading // Handle SourSimRL reading
if ( type == RiaDefines::SOURSIMRL ) if ( type == RiaDefines::ResultCatType::SOURSIMRL )
{ {
RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>( m_readerInterface.p() ); RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>( m_readerInterface.p() );
if ( eclReader ) if ( eclReader )
@ -1547,18 +1594,18 @@ void RigCaseCellResultsData::computeSOILForTimeStep( size_t timeStepIndex )
// Compute SGAS based on SWAT if the simulation contains no oil // Compute SGAS based on SWAT if the simulation contains no oil
testAndComputeSgasForTimeStep( timeStepIndex ); testAndComputeSgasForTimeStep( timeStepIndex );
RigEclipseResultAddress SWATAddr( RiaDefines::DYNAMIC_NATIVE, "SWAT" ); RigEclipseResultAddress SWATAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" );
RigEclipseResultAddress SGASAddr( RiaDefines::DYNAMIC_NATIVE, "SGAS" ); RigEclipseResultAddress SGASAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" );
RigEclipseResultAddress SSOLAddr( RiaDefines::DYNAMIC_NATIVE, "SSOL" ); RigEclipseResultAddress SSOLAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SSOL" );
size_t scalarIndexSWAT = size_t scalarIndexSWAT =
findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ), findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ),
timeStepIndex ); timeStepIndex );
size_t scalarIndexSGAS = size_t scalarIndexSGAS =
findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ), findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ),
timeStepIndex ); timeStepIndex );
size_t scalarIndexSSOL = size_t scalarIndexSSOL =
findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SSOL" ), findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SSOL" ),
timeStepIndex ); timeStepIndex );
// Early exit if none of SWAT or SGAS is present // Early exit if none of SWAT or SGAS is present
@ -1593,7 +1640,7 @@ void RigCaseCellResultsData::computeSOILForTimeStep( size_t timeStepIndex )
} }
// Make sure memory is allocated for the new SOIL results // Make sure memory is allocated for the new SOIL results
RigEclipseResultAddress SOILAddr( RiaDefines::DYNAMIC_NATIVE, "SOIL" ); RigEclipseResultAddress SOILAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" );
size_t soilResultScalarIndex = this->findScalarResultIndexFromAddress( SOILAddr ); size_t soilResultScalarIndex = this->findScalarResultIndexFromAddress( SOILAddr );
m_cellScalarResults[soilResultScalarIndex].resize( soilTimeStepCount ); m_cellScalarResults[soilResultScalarIndex].resize( soilTimeStepCount );
@ -1667,7 +1714,7 @@ void RigCaseCellResultsData::computeSOILForTimeStep( size_t timeStepIndex )
void RigCaseCellResultsData::testAndComputeSgasForTimeStep( size_t timeStepIndex ) void RigCaseCellResultsData::testAndComputeSgasForTimeStep( size_t timeStepIndex )
{ {
size_t scalarIndexSWAT = size_t scalarIndexSWAT =
findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ), findOrLoadKnownScalarResultForTimeStep( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ),
timeStepIndex ); timeStepIndex );
if ( scalarIndexSWAT == cvf::UNDEFINED_SIZE_T ) if ( scalarIndexSWAT == cvf::UNDEFINED_SIZE_T )
{ {
@ -1683,7 +1730,8 @@ void RigCaseCellResultsData::testAndComputeSgasForTimeStep( size_t timeStepIndex
// Simulation type is gas and water. No SGAS is present, compute SGAS based on SWAT // Simulation type is gas and water. No SGAS is present, compute SGAS based on SWAT
size_t scalarIndexSGAS = size_t scalarIndexSGAS =
this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ), false ); this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ),
false );
if ( m_cellScalarResults[scalarIndexSGAS].size() > timeStepIndex ) if ( m_cellScalarResults[scalarIndexSGAS].size() > timeStepIndex )
{ {
std::vector<double>& values = m_cellScalarResults[scalarIndexSGAS][timeStepIndex]; std::vector<double>& values = m_cellScalarResults[scalarIndexSGAS][timeStepIndex];
@ -1745,13 +1793,18 @@ void RigCaseCellResultsData::computeDepthRelatedResults()
size_t actCellCount = activeCellInfo()->reservoirActiveCellCount(); size_t actCellCount = activeCellInfo()->reservoirActiveCellCount();
if ( actCellCount == 0 ) return; if ( actCellCount == 0 ) return;
size_t depthResultIndex = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DEPTH" ) ); size_t depthResultIndex =
size_t dxResultIndex = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DX" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DEPTH" ) );
size_t dyResultIndex = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DY" ) ); size_t dxResultIndex =
size_t dzResultIndex = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DX" ) );
size_t topsResultIndex = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "TOPS" ) ); size_t dyResultIndex =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DY" ) );
size_t dzResultIndex =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ" ) );
size_t topsResultIndex =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TOPS" ) );
size_t bottomResultIndex = size_t bottomResultIndex =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "BOTTOM" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "BOTTOM" ) );
bool computeDepth = false; bool computeDepth = false;
bool computeDx = false; bool computeDx = false;
@ -1762,37 +1815,40 @@ void RigCaseCellResultsData::computeDepthRelatedResults()
if ( depthResultIndex == cvf::UNDEFINED_SIZE_T ) if ( depthResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
depthResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "DEPTH", false, actCellCount ); depthResultIndex =
this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "DEPTH", false, actCellCount );
computeDepth = true; computeDepth = true;
} }
if ( dxResultIndex == cvf::UNDEFINED_SIZE_T ) if ( dxResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
dxResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "DX", false, actCellCount ); dxResultIndex = this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "DX", false, actCellCount );
computeDx = true; computeDx = true;
} }
if ( dyResultIndex == cvf::UNDEFINED_SIZE_T ) if ( dyResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
dyResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "DY", false, actCellCount ); dyResultIndex = this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "DY", false, actCellCount );
computeDy = true; computeDy = true;
} }
if ( dzResultIndex == cvf::UNDEFINED_SIZE_T ) if ( dzResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
dzResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "DZ", false, actCellCount ); dzResultIndex = this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "DZ", false, actCellCount );
computeDz = true; computeDz = true;
} }
if ( topsResultIndex == cvf::UNDEFINED_SIZE_T ) if ( topsResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
topsResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "TOPS", false, actCellCount ); topsResultIndex =
this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "TOPS", false, actCellCount );
computeTops = true; computeTops = true;
} }
if ( bottomResultIndex == cvf::UNDEFINED_SIZE_T ) if ( bottomResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
bottomResultIndex = this->addStaticScalarResult( RiaDefines::STATIC_NATIVE, "BOTTOM", false, actCellCount ); bottomResultIndex =
this->addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, "BOTTOM", false, actCellCount );
computeBottom = true; computeBottom = true;
} }
@ -2018,15 +2074,16 @@ void RigCaseCellResultsData::computeRiTransComponent( const QString& riTransComp
// Get the needed result indices we depend on // Get the needed result indices we depend on
size_t permResultIdx = size_t permResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, permCompName ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, permCompName ) );
size_t ntgResultIdx = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); size_t ntgResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T; bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T;
// Get the result index of the output // Get the result index of the output
size_t riTransResultIdx = this->findScalarResultIndexFromAddress( size_t riTransResultIdx = this->findScalarResultIndexFromAddress(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, riTransComponentResultName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, riTransComponentResultName ) );
CVF_ASSERT( riTransResultIdx != cvf::UNDEFINED_SIZE_T ); CVF_ASSERT( riTransResultIdx != cvf::UNDEFINED_SIZE_T );
// Get the result count, to handle that one of them might be globally defined // Get the result count, to handle that one of them might be globally defined
@ -2058,15 +2115,15 @@ void RigCaseCellResultsData::computeRiTransComponent( const QString& riTransComp
ResultIndexFunction permIdxFunc = nullptr; ResultIndexFunction permIdxFunc = nullptr;
ResultIndexFunction ntgIdxFunc = nullptr; ResultIndexFunction ntgIdxFunc = nullptr;
{ {
bool isPermUsingResIdx = bool isPermUsingResIdx = this->isUsingGlobalActiveIndex(
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, permCompName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, permCompName ) );
bool isTransUsingResIdx = this->isUsingGlobalActiveIndex( bool isTransUsingResIdx = this->isUsingGlobalActiveIndex(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, riTransComponentResultName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, riTransComponentResultName ) );
bool isNtgUsingResIdx = false; bool isNtgUsingResIdx = false;
if ( hasNTGResults ) if ( hasNTGResults )
{ {
isNtgUsingResIdx = isNtgUsingResIdx = this->isUsingGlobalActiveIndex(
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
} }
// Set up result index function pointers // Set up result index function pointers
@ -2175,18 +2232,23 @@ void RigCaseCellResultsData::computeRiTransComponent( const QString& riTransComp
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeNncCombRiTrans() void RigCaseCellResultsData::computeNncCombRiTrans()
{ {
RigEclipseResultAddress riCombTransEclResAddr( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName() ); RigEclipseResultAddress riCombTransEclResAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::combinedRiTranResultName() );
if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombTransEclResAddr ) ) return; if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombTransEclResAddr ) ) return;
double cdarchy = darchysValue(); double cdarchy = darchysValue();
// Get the needed result indices we depend on // Get the needed result indices we depend on
size_t permXResultIdx = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); size_t permXResultIdx =
size_t permYResultIdx = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMX" ) );
size_t permZResultIdx = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); size_t permYResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) );
size_t permZResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) );
size_t ntgResultIdx = findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); size_t ntgResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T; bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T;
@ -2212,16 +2274,16 @@ void RigCaseCellResultsData::computeNncCombRiTrans()
ResultIndexFunction ntgIdxFunc = nullptr; ResultIndexFunction ntgIdxFunc = nullptr;
{ {
bool isPermXUsingResIdx = bool isPermXUsingResIdx =
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMX" ) ); this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMX" ) );
bool isPermYUsingResIdx = bool isPermYUsingResIdx =
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMY" ) ); this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) );
bool isPermZUsingResIdx = bool isPermZUsingResIdx =
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PERMZ" ) ); this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) );
bool isNtgUsingResIdx = false; bool isNtgUsingResIdx = false;
if ( hasNTGResults ) if ( hasNTGResults )
{ {
isNtgUsingResIdx = isNtgUsingResIdx = this->isUsingGlobalActiveIndex(
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "NTG" ) );
} }
// Set up result index function pointers // Set up result index function pointers
@ -2398,14 +2460,14 @@ void RigCaseCellResultsData::computeRiMULTComponent( const QString& riMultCompNa
// Get the needed result indices we depend on // Get the needed result indices we depend on
size_t transResultIdx = size_t transResultIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, transCompName ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, transCompName ) );
size_t riTransResultIdx = size_t riTransResultIdx = findOrLoadKnownScalarResult(
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, riTransCompName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, riTransCompName ) );
// Get the result index of the output // Get the result index of the output
size_t riMultResultIdx = size_t riMultResultIdx = this->findScalarResultIndexFromAddress(
this->findScalarResultIndexFromAddress( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, riMultCompName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, riMultCompName ) );
CVF_ASSERT( riMultResultIdx != cvf::UNDEFINED_SIZE_T ); CVF_ASSERT( riMultResultIdx != cvf::UNDEFINED_SIZE_T );
// Get the result count, to handle that one of them might be globally defined // Get the result count, to handle that one of them might be globally defined
@ -2436,11 +2498,11 @@ void RigCaseCellResultsData::computeRiMULTComponent( const QString& riMultCompNa
void RigCaseCellResultsData::computeNncCombRiMULT() void RigCaseCellResultsData::computeNncCombRiMULT()
{ {
auto riCombMultEclResAddr = auto riCombMultEclResAddr =
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName() ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::combinedRiMultResultName() );
auto riCombTransEclResAddr = auto riCombTransEclResAddr =
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName() ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::combinedRiTranResultName() );
auto combTransEclResAddr = auto combTransEclResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName() ); RiaDefines::combinedTransmissibilityResultName() );
if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombMultEclResAddr ) ) return; if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombMultEclResAddr ) ) return;
@ -2497,12 +2559,12 @@ void RigCaseCellResultsData::computeRiTRANSbyAreaComponent( const QString& riTra
// Get the needed result indices we depend on // Get the needed result indices we depend on
size_t tranCompScResIdx = size_t tranCompScResIdx =
findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, transCompName ) ); findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, transCompName ) );
// Get the result index of the output // Get the result index of the output
size_t riTranByAreaScResIdx = this->findScalarResultIndexFromAddress( size_t riTranByAreaScResIdx = this->findScalarResultIndexFromAddress(
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, riTransByAreaCompResultName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, riTransByAreaCompResultName ) );
CVF_ASSERT( riTranByAreaScResIdx != cvf::UNDEFINED_SIZE_T ); CVF_ASSERT( riTranByAreaScResIdx != cvf::UNDEFINED_SIZE_T );
// Get the result count, to handle that one of them might be globally defined // Get the result count, to handle that one of them might be globally defined
@ -2520,8 +2582,8 @@ void RigCaseCellResultsData::computeRiTRANSbyAreaComponent( const QString& riTra
// Prepare how to index the result values: // Prepare how to index the result values:
bool isUsingResIdx = bool isUsingResIdx = this->isUsingGlobalActiveIndex(
this->isUsingGlobalActiveIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, transCompName ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, transCompName ) );
// Set up result index function pointers // Set up result index function pointers
@ -2581,10 +2643,10 @@ void RigCaseCellResultsData::computeRiTRANSbyAreaComponent( const QString& riTra
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeNncCombRiTRANSbyArea() void RigCaseCellResultsData::computeNncCombRiTRANSbyArea()
{ {
auto riCombTransByAreaEclResAddr = auto riCombTransByAreaEclResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName() ); RiaDefines::combinedRiAreaNormTranResultName() );
auto combTransEclResAddr = auto combTransEclResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName() ); RiaDefines::combinedTransmissibilityResultName() );
if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombTransByAreaEclResAddr ) ) return; if ( m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombTransByAreaEclResAddr ) ) return;
@ -2619,7 +2681,7 @@ void RigCaseCellResultsData::computeNncCombRiTRANSbyArea()
void RigCaseCellResultsData::computeCompletionTypeForTimeStep( size_t timeStep ) void RigCaseCellResultsData::computeCompletionTypeForTimeStep( size_t timeStep )
{ {
size_t completionTypeResultIndex = this->findScalarResultIndexFromAddress( size_t completionTypeResultIndex = this->findScalarResultIndexFromAddress(
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName() ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName() ) );
if ( m_cellScalarResults[completionTypeResultIndex].size() < this->maxTimeStepCount() ) if ( m_cellScalarResults[completionTypeResultIndex].size() < this->maxTimeStepCount() )
{ {
@ -2659,7 +2721,7 @@ double RigCaseCellResultsData::darchysValue()
void RigCaseCellResultsData::computeCellVolumes() void RigCaseCellResultsData::computeCellVolumes()
{ {
size_t cellVolIdx = size_t cellVolIdx =
this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riCellVolumeResultName() ), RiaDefines::riCellVolumeResultName() ),
false ); false );
@ -2688,7 +2750,7 @@ void RigCaseCellResultsData::computeCellVolumes()
} }
// Clear oil volume so it will have to be recalculated. // Clear oil volume so it will have to be recalculated.
clearScalarResult( RiaDefines::DYNAMIC_NATIVE, RiaDefines::riOilVolumeResultName() ); clearScalarResult( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::riOilVolumeResultName() );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -2697,13 +2759,15 @@ void RigCaseCellResultsData::computeCellVolumes()
void RigCaseCellResultsData::computeOilVolumes() void RigCaseCellResultsData::computeOilVolumes()
{ {
size_t cellVolIdx = size_t cellVolIdx =
this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::riCellVolumeResultName() ), RiaDefines::riCellVolumeResultName() ),
false ); false );
const std::vector<double>& cellVolumeResults = m_cellScalarResults[cellVolIdx][0]; const std::vector<double>& cellVolumeResults = m_cellScalarResults[cellVolIdx][0];
size_t soilIdx = this->findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ) ); size_t soilIdx =
size_t oilVolIdx = this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, this->findOrLoadKnownScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) );
size_t oilVolIdx =
this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::riOilVolumeResultName() ), RiaDefines::riOilVolumeResultName() ),
false ); false );
m_cellScalarResults[oilVolIdx].resize( this->maxTimeStepCount() ); m_cellScalarResults[oilVolIdx].resize( this->maxTimeStepCount() );
@ -2760,7 +2824,8 @@ void RigCaseCellResultsData::computeMobilePV()
multpvResults = multpvResults =
RigCaseCellResultsData::getResultIndexableStaticResult( this->activeCellInfo(), this, "MULTPV", multpvDataTemp ); RigCaseCellResultsData::getResultIndexableStaticResult( this->activeCellInfo(), this, "MULTPV", multpvDataTemp );
size_t mobPVIdx = this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, size_t mobPVIdx =
this->findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::mobilePoreVolumeName() ), RiaDefines::mobilePoreVolumeName() ),
false ); false );
@ -2837,13 +2902,13 @@ void RigCaseCellResultsData::setActiveFormationNames( RigFormationNames* activeF
m_activeFormationNamesData = activeFormationNames; m_activeFormationNamesData = activeFormationNames;
size_t totalGlobCellCount = m_ownerMainGrid->globalCellArray().size(); size_t totalGlobCellCount = m_ownerMainGrid->globalCellArray().size();
this->addStaticScalarResult( RiaDefines::FORMATION_NAMES, this->addStaticScalarResult( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName(), RiaDefines::activeFormationNamesResultName(),
false, false,
totalGlobCellCount ); totalGlobCellCount );
std::vector<double>* fnData = std::vector<double>* fnData =
this->modifiableCellScalarResult( RigEclipseResultAddress( RiaDefines::FORMATION_NAMES, this->modifiableCellScalarResult( RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName() ), RiaDefines::activeFormationNamesResultName() ),
0 ); 0 );
@ -3011,16 +3076,16 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
CVF_ASSERT( mainGrid ); CVF_ASSERT( mainGrid );
CVF_ASSERT( cellResultsData ); CVF_ASSERT( cellResultsData );
auto fnNamesResAddr = auto fnNamesResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RigEclipseResultAddress( RiaDefines::FORMATION_NAMES, RiaDefines::activeFormationNamesResultName() ); RiaDefines::activeFormationNamesResultName() );
bool hasFormationData = cellResultsData->hasResultEntry( fnNamesResAddr ); bool hasFormationData = cellResultsData->hasResultEntry( fnNamesResAddr );
if ( hasFormationData ) if ( hasFormationData )
{ {
auto fnAllenResultResAddr = auto fnAllenResultResAddr =
RigEclipseResultAddress( RiaDefines::ALLEN_DIAGRAMS, RiaDefines::formationAllenResultName() ); RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, RiaDefines::formationAllenResultName() );
auto fnBinAllenResAddr = auto fnBinAllenResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RigEclipseResultAddress( RiaDefines::ALLEN_DIAGRAMS, RiaDefines::formationBinaryAllenResultName() ); RiaDefines::formationBinaryAllenResultName() );
// Create and retreive nnc result arrays // Create and retreive nnc result arrays
@ -3038,11 +3103,11 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
// Add a result entry for the special allen grid data (used only for the grid cells without nnc coverage) // Add a result entry for the special allen grid data (used only for the grid cells without nnc coverage)
cellResultsData->addStaticScalarResult( RiaDefines::ALLEN_DIAGRAMS, cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationAllenResultName(), RiaDefines::formationAllenResultName(),
false, false,
fnData.size() ); fnData.size() );
cellResultsData->addStaticScalarResult( RiaDefines::ALLEN_DIAGRAMS, cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName(), RiaDefines::formationBinaryAllenResultName(),
false, false,
fnData.size() ); fnData.size() );
@ -3149,41 +3214,41 @@ size_t RigCaseCellResultsData::findScalarResultIndexFromAddress( const RigEclips
{ {
return cvf::UNDEFINED_SIZE_T; return cvf::UNDEFINED_SIZE_T;
} }
else if ( resVarAddr.m_resultCatType == RiaDefines::UNDEFINED ) else if ( resVarAddr.m_resultCatType == RiaDefines::ResultCatType::UNDEFINED )
{ {
RigEclipseResultAddress resVarAddressWithType = resVarAddr; RigEclipseResultAddress resVarAddressWithType = resVarAddr;
resVarAddressWithType.m_resultCatType = RiaDefines::STATIC_NATIVE; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::STATIC_NATIVE;
size_t scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); size_t scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
resVarAddressWithType.m_resultCatType = RiaDefines::DYNAMIC_NATIVE; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::DYNAMIC_NATIVE;
scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
} }
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
resVarAddressWithType.m_resultCatType = RiaDefines::SOURSIMRL; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::SOURSIMRL;
scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
} }
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
resVarAddressWithType.m_resultCatType = RiaDefines::GENERATED; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::GENERATED;
scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
} }
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
resVarAddressWithType.m_resultCatType = RiaDefines::INPUT_PROPERTY; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::INPUT_PROPERTY;
scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
} }
if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T ) if ( scalarResultIndex == cvf::UNDEFINED_SIZE_T )
{ {
resVarAddressWithType.m_resultCatType = RiaDefines::FORMATION_NAMES; resVarAddressWithType.m_resultCatType = RiaDefines::ResultCatType::FORMATION_NAMES;
scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType ); scalarResultIndex = this->findScalarResultIndexFromAddress( resVarAddressWithType );
} }

4
ApplicationCode/ReservoirDataModel/RigEclipseResultAddress.h
View File

@ -25,14 +25,14 @@ class RigEclipseResultAddress
{ {
public: public:
RigEclipseResultAddress() RigEclipseResultAddress()
: m_resultCatType( RiaDefines::UNDEFINED ) : m_resultCatType( RiaDefines::ResultCatType::UNDEFINED )
, m_timeLapseBaseFrameIdx( NO_TIME_LAPSE ) , m_timeLapseBaseFrameIdx( NO_TIME_LAPSE )
, m_differenceCaseId( NO_CASE_DIFF ) , m_differenceCaseId( NO_CASE_DIFF )
{ {
} }
explicit RigEclipseResultAddress( const QString& resultName ) explicit RigEclipseResultAddress( const QString& resultName )
: m_resultCatType( RiaDefines::UNDEFINED ) : m_resultCatType( RiaDefines::ResultCatType::UNDEFINED )
, m_resultName( resultName ) , m_resultName( resultName )
, m_timeLapseBaseFrameIdx( NO_TIME_LAPSE ) , m_timeLapseBaseFrameIdx( NO_TIME_LAPSE )
, m_differenceCaseId( NO_CASE_DIFF ) , m_differenceCaseId( NO_CASE_DIFF )

18
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@ -562,16 +562,22 @@ void RigFlowDiagSolverInterface::assignPhaseCorrecedPORV( RigFlowDiagResultAddre
switch ( phaseSelection ) switch ( phaseSelection )
{ {
case RigFlowDiagResultAddress::PHASE_OIL: case RigFlowDiagResultAddress::PHASE_OIL:
phaseSaturation = phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SOIL", timeStepIdx ); RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL",
timeStepIdx );
break; break;
case RigFlowDiagResultAddress::PHASE_GAS: case RigFlowDiagResultAddress::PHASE_GAS:
phaseSaturation = phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SGAS", timeStepIdx ); RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS",
timeStepIdx );
break; break;
case RigFlowDiagResultAddress::PHASE_WAT: case RigFlowDiagResultAddress::PHASE_WAT:
phaseSaturation = phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SWAT", timeStepIdx ); RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT",
timeStepIdx );
break; break;
default: default:
m_opmFlowDiagStaticData->m_fldToolbox->assignPoreVolume( m_opmFlowDiagStaticData->m_poreVolume ); m_opmFlowDiagStaticData->m_fldToolbox->assignPoreVolume( m_opmFlowDiagStaticData->m_poreVolume );

8
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -73,7 +73,7 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
std::vector<RigEclipseResultAddress> tracerResAddrs; std::vector<RigEclipseResultAddress> tracerResAddrs;
for ( QString tracerName : tracerNames ) for ( QString tracerName : tracerNames )
{ {
RigEclipseResultAddress tracerResAddr( RiaDefines::DYNAMIC_NATIVE, tracerName ); RigEclipseResultAddress tracerResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, tracerName );
if ( gridCellResults->ensureKnownResultLoaded( tracerResAddr ) ) if ( gridCellResults->ensureKnownResultLoaded( tracerResAddr ) )
{ {
tracerResAddrs.push_back( tracerResAddr ); tracerResAddrs.push_back( tracerResAddr );
@ -83,9 +83,9 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
std::vector<std::vector<double>> summedTracersAtAllTimesteps; std::vector<std::vector<double>> summedTracersAtAllTimesteps;
// TODO: Option for Oil and Gas instead of water // TODO: Option for Oil and Gas instead of water
RigEclipseResultAddress flrWatIAddr( RiaDefines::DYNAMIC_NATIVE, "FLRWATI+" ); RigEclipseResultAddress flrWatIAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" );
RigEclipseResultAddress flrWatJAddr( RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+" ); RigEclipseResultAddress flrWatJAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" );
RigEclipseResultAddress flrWatKAddr( RiaDefines::DYNAMIC_NATIVE, "FLRWATK+" ); RigEclipseResultAddress flrWatKAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" );
bool hasFlowrateI = gridCellResults->ensureKnownResultLoaded( flrWatIAddr ); bool hasFlowrateI = gridCellResults->ensureKnownResultLoaded( flrWatIAddr );
progress.incrementProgress(); progress.incrementProgress();

4
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@ -95,8 +95,8 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultAddress( c
} }
size_t adjustedTimeStepIndex = timeStepIndex; size_t adjustedTimeStepIndex = timeStepIndex;
if ( resVarAddr.m_resultCatType == RiaDefines::STATIC_NATIVE || if ( resVarAddr.m_resultCatType == RiaDefines::ResultCatType::STATIC_NATIVE ||
resVarAddr.m_resultCatType == RiaDefines::FORMATION_NAMES ) resVarAddr.m_resultCatType == RiaDefines::ResultCatType::FORMATION_NAMES )
{ {
adjustedTimeStepIndex = 0; adjustedTimeStepIndex = 0;
} }

8
ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
View File

@ -45,13 +45,13 @@ RigTofAccumulatedPhaseFractionsCalculator::RigTofAccumulatedPhaseFractionsCalcul
if ( !eclipseCaseData ) return; if ( !eclipseCaseData ) return;
const std::vector<double>* swatResults = const std::vector<double>* swatResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SWAT", timestep ); eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT", timestep );
const std::vector<double>* soilResults = const std::vector<double>* soilResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SOIL", timestep ); eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL", timestep );
const std::vector<double>* sgasResults = const std::vector<double>* sgasResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, "SGAS", timestep ); eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS", timestep );
const std::vector<double>* porvResults = const std::vector<double>* porvResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::STATIC_NATIVE, "PORV", 0 ); eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::STATIC_NATIVE, "PORV", 0 );
RimFlowDiagSolution* flowDiagSolution = caseToApply->defaultFlowDiagSolution(); RimFlowDiagSolution* flowDiagSolution = caseToApply->defaultFlowDiagSolution();

8
ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
View File

@ -61,7 +61,7 @@ RigTofWellDistributionCalculator::RigTofWellDistributionCalculator( RimEclipseRe
CVF_ASSERT( flowDiagResults ); CVF_ASSERT( flowDiagResults );
const std::vector<double>* porvResults = const std::vector<double>* porvResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::STATIC_NATIVE, "PORV", 0 ); eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::STATIC_NATIVE, "PORV", 0 );
if ( !porvResults ) if ( !porvResults )
{ {
return; return;
@ -74,8 +74,10 @@ RigTofWellDistributionCalculator::RigTofWellDistributionCalculator( RimEclipseRe
phaseResultName = "SOIL"; phaseResultName = "SOIL";
else if ( phase == RiaDefines::GAS_PHASE ) else if ( phase == RiaDefines::GAS_PHASE )
phaseResultName = "SGAS"; phaseResultName = "SGAS";
const std::vector<double>* phaseResults = const std::vector<double>* phaseResults = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, phaseResultName, timeStepIndex ); RiaDefines::ResultCatType::DYNAMIC_NATIVE,
phaseResultName,
timeStepIndex );
if ( !phaseResults ) if ( !phaseResults )
{ {
return; return;

2
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -444,7 +444,7 @@ private:
static bool scalarResultExistsOrCreate( RigCaseCellResultsData* results, QString propertyName ) static bool scalarResultExistsOrCreate( RigCaseCellResultsData* results, QString propertyName )
{ {
RigEclipseResultAddress resAddr( RiaDefines::GENERATED, propertyName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, propertyName );
if ( !results->ensureKnownResultLoaded( resAddr ) ) if ( !results->ensureKnownResultLoaded( resAddr ) )
{ {

16
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -427,7 +427,7 @@ public:
if ( rimCase && rimCase->results( m_porosityModelEnum ) ) if ( rimCase && rimCase->results( m_porosityModelEnum ) )
{ {
RigEclipseResultAddress eclResAddr( RiaDefines::GENERATED, propertyName ); RigEclipseResultAddress eclResAddr( RiaDefines::ResultCatType::GENERATED, propertyName );
if ( !rimCase->results( m_porosityModelEnum )->ensureKnownResultLoaded( eclResAddr ) ) if ( !rimCase->results( m_porosityModelEnum )->ensureKnownResultLoaded( eclResAddr ) )
{ {
@ -844,7 +844,7 @@ public:
if ( rimCase && rimCase->results( m_porosityModelEnum ) ) if ( rimCase && rimCase->results( m_porosityModelEnum ) )
{ {
RigEclipseResultAddress resAddr( RiaDefines::GENERATED, propertyName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, propertyName );
if ( !rimCase->results( m_porosityModelEnum )->ensureKnownResultLoaded( resAddr ) ) if ( !rimCase->results( m_porosityModelEnum )->ensureKnownResultLoaded( resAddr ) )
{ {
@ -1179,18 +1179,18 @@ public:
std::vector<RiaDefines::ResultCatType> resTypes; std::vector<RiaDefines::ResultCatType> resTypes;
std::vector<QString> resTypeNames; std::vector<QString> resTypeNames;
resTypes.push_back( RiaDefines::DYNAMIC_NATIVE ); resTypes.push_back( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
resTypeNames.push_back( "DynamicNative" ); resTypeNames.push_back( "DynamicNative" );
resTypes.push_back( RiaDefines::SOURSIMRL ); resTypes.push_back( RiaDefines::ResultCatType::SOURSIMRL );
resTypeNames.push_back( "SourSimRL" ); resTypeNames.push_back( "SourSimRL" );
resTypes.push_back( RiaDefines::STATIC_NATIVE ); resTypes.push_back( RiaDefines::ResultCatType::STATIC_NATIVE );
resTypeNames.push_back( "StaticNative" ); resTypeNames.push_back( "StaticNative" );
resTypes.push_back( RiaDefines::GENERATED ); resTypes.push_back( RiaDefines::ResultCatType::GENERATED );
resTypeNames.push_back( "Generated" ); resTypeNames.push_back( "Generated" );
resTypes.push_back( RiaDefines::INPUT_PROPERTY ); resTypes.push_back( RiaDefines::ResultCatType::INPUT_PROPERTY );
resTypeNames.push_back( "Input" ); resTypeNames.push_back( "Input" );
#ifdef ENABLE_SOURING #ifdef ENABLE_SOURING
resTypes.push_back( RiaDefines::INJECTION_FLOODING ); resTypes.push_back( RiaDefines::ResultCatType::INJECTION_FLOODING );
resTypeNames.push_back( "Injection Flooding" ); resTypeNames.push_back( "Injection Flooding" );
#endif /* ENABLE_SOURING */ #endif /* ENABLE_SOURING */

8
ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -60,11 +60,11 @@ TEST( RigReservoirTest, BasicTest10k )
{ {
RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL ); RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL );
QStringList staticResults = cellData->resultNames( STATIC_NATIVE ); QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE );
EXPECT_EQ( 0, staticResults.size() ); EXPECT_EQ( 0, staticResults.size() );
// qDebug() << "Static results\n" << staticResults; // qDebug() << "Static results\n" << staticResults;
QStringList dynamicResults = cellData->resultNames( DYNAMIC_NATIVE ); QStringList dynamicResults = cellData->resultNames( ResultCatType::DYNAMIC_NATIVE );
EXPECT_EQ( 0, dynamicResults.size() ); EXPECT_EQ( 0, dynamicResults.size() );
// qDebug() << "Dynamic results\n" << dynamicResults; // qDebug() << "Dynamic results\n" << dynamicResults;
@ -83,11 +83,11 @@ TEST( RigReservoirTest, BasicTest10k )
{ {
RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL ); RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL );
QStringList staticResults = cellData->resultNames( STATIC_NATIVE ); QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE );
EXPECT_EQ( 44, staticResults.size() ); EXPECT_EQ( 44, staticResults.size() );
// qDebug() << "Static results\n" << staticResults; // qDebug() << "Static results\n" << staticResults;
QStringList dynamicResults = cellData->resultNames( DYNAMIC_NATIVE ); QStringList dynamicResults = cellData->resultNames( ResultCatType::DYNAMIC_NATIVE );
EXPECT_EQ( 23, dynamicResults.size() ); EXPECT_EQ( 23, dynamicResults.size() );
// qDebug() << "Dynamic results\n" << dynamicResults; // qDebug() << "Dynamic results\n" << dynamicResults;

20
ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
View File

@ -166,38 +166,42 @@ bool RiuPvtPlotUpdater::queryDataAndUpdatePlot( const RimEclipseResultDefinition
// The following calls will read results from file in preparation for the queries below // The following calls will read results from file in preparation for the queries below
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL );
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "RS" ) ); cellResultsData->ensureKnownResultLoaded(
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "RV" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "RS" ) );
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "PRESSURE" ) ); cellResultsData->ensureKnownResultLoaded(
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PVTNUM" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "RV" ) );
cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) );
cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PVTNUM" ) );
cvf::ref<RigResultAccessor> rsAccessor = cvf::ref<RigResultAccessor> rsAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"RS" ) ); "RS" ) );
cvf::ref<RigResultAccessor> rvAccessor = cvf::ref<RigResultAccessor> rvAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"RV" ) ); "RV" ) );
cvf::ref<RigResultAccessor> pressureAccessor = cvf::ref<RigResultAccessor> pressureAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"PRESSURE" ) ); "PRESSURE" ) );
cvf::ref<RigResultAccessor> pvtnumAccessor = cvf::ref<RigResultAccessor> pvtnumAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PVTNUM" ) ); "PVTNUM" ) );
RiuPvtPlotPanel::CellValues cellValues; RiuPvtPlotPanel::CellValues cellValues;

15
ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
View File

@ -161,9 +161,12 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
// Make sure we load the results that we'll query below // Make sure we load the results that we'll query below
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL );
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ) ); cellResultsData->ensureKnownResultLoaded(
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "SATNUM" ) ); cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "SATNUM" ) );
// Fetch SWAT and SGAS cell values for the selected cell // Fetch SWAT and SGAS cell values for the selected cell
cvf::ref<RigResultAccessor> swatAccessor = cvf::ref<RigResultAccessor> swatAccessor =
@ -171,21 +174,21 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT" ) ); "SWAT" ) );
cvf::ref<RigResultAccessor> sgasAccessor = cvf::ref<RigResultAccessor> sgasAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS" ) ); "SGAS" ) );
cvf::ref<RigResultAccessor> satnumAccessor = cvf::ref<RigResultAccessor> satnumAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"SATNUM" ) ); "SATNUM" ) );
const double cellSWAT = swatAccessor.notNull() ? swatAccessor->cellScalar( gridLocalCellIndex ) : HUGE_VAL; const double cellSWAT = swatAccessor.notNull() ? swatAccessor->cellScalar( gridLocalCellIndex ) : HUGE_VAL;
const double cellSGAS = sgasAccessor.notNull() ? sgasAccessor->cellScalar( gridLocalCellIndex ) : HUGE_VAL; const double cellSGAS = sgasAccessor.notNull() ? sgasAccessor->cellScalar( gridLocalCellIndex ) : HUGE_VAL;

38
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -323,7 +323,7 @@ QString RiuResultTextBuilder::faultResultDetails()
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->faultResultSettings()->hasValidCustomResult() ) if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->faultResultSettings()->hasValidCustomResult() )
{ {
if ( m_viewWithFaultsSettings->faultResultSettings()->customFaultResult()->resultType() != if ( m_viewWithFaultsSettings->faultResultSettings()->customFaultResult()->resultType() !=
RiaDefines::ALLEN_DIAGRAMS ) RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
text += "Fault result data:\n"; text += "Fault result data:\n";
this->appendTextFromResultColors( eclipseCaseData, this->appendTextFromResultColors( eclipseCaseData,
@ -457,11 +457,11 @@ QString RiuResultTextBuilder::nncResultText()
const std::vector<double>* nncValues = nullptr; const std::vector<double>* nncValues = nullptr;
if ( resultType == RiaDefines::STATIC_NATIVE ) if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE )
{ {
nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress ); nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress );
} }
else if ( resultType == RiaDefines::DYNAMIC_NATIVE ) else if ( resultType == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
{ {
if ( m_eclResDef.notNull() && m_eclResDef->eclipseCase() ) if ( m_eclResDef.notNull() && m_eclResDef->eclipseCase() )
{ {
@ -478,7 +478,7 @@ QString RiuResultTextBuilder::nncResultText()
text = QString( "%1 : %2" ).arg( resultVar ).arg( scalarValue ); text = QString( "%1 : %2" ).arg( resultVar ).arg( scalarValue );
} }
if ( resultType == RiaDefines::ALLEN_DIAGRAMS ) if ( resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
{ {
nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress ); nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress );
QString resultValueText; QString resultValueText;
@ -540,30 +540,33 @@ void RiuResultTextBuilder::appendTextFromResultColors( RigEclipseCaseData*
RigCaseCellResultsData* gridCellResults = resultColors->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = resultColors->currentGridCellResults();
if ( gridCellResults ) if ( gridCellResults )
{ {
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ) ); gridCellResults->ensureKnownResultLoaded(
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) );
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ) ); gridCellResults->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
gridCellResults->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
cvf::ref<RigResultAccessor> dataAccessObjectX = cvf::ref<RigResultAccessor> dataAccessObjectX =
RigResultAccessorFactory::createFromResultAddress( eclipseCase, RigResultAccessorFactory::createFromResultAddress( eclipseCase,
gridIndex, gridIndex,
porosityModel, porosityModel,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL" ) ); "SOIL" ) );
cvf::ref<RigResultAccessor> dataAccessObjectY = cvf::ref<RigResultAccessor> dataAccessObjectY =
RigResultAccessorFactory::createFromResultAddress( eclipseCase, RigResultAccessorFactory::createFromResultAddress( eclipseCase,
gridIndex, gridIndex,
porosityModel, porosityModel,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS" ) ); "SGAS" ) );
cvf::ref<RigResultAccessor> dataAccessObjectZ = cvf::ref<RigResultAccessor> dataAccessObjectZ =
RigResultAccessorFactory::createFromResultAddress( eclipseCase, RigResultAccessorFactory::createFromResultAddress( eclipseCase,
gridIndex, gridIndex,
porosityModel, porosityModel,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT" ) ); "SWAT" ) );
double scalarValue = 0.0; double scalarValue = 0.0;
@ -894,9 +897,12 @@ QString RiuResultTextBuilder::cellResultText( RimEclipseResultDefinition* eclRes
RigCaseCellResultsData* gridCellResults = m_eclResDef->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = m_eclResDef->currentGridCellResults();
if ( gridCellResults ) if ( gridCellResults )
{ {
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SOIL" ) ); gridCellResults->ensureKnownResultLoaded(
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SGAS" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) );
gridCellResults->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, "SWAT" ) ); gridCellResults->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
gridCellResults->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
RiaDefines::PorosityModelType porosityModel = eclResDef->porosityModel(); RiaDefines::PorosityModelType porosityModel = eclResDef->porosityModel();
@ -905,21 +911,21 @@ QString RiuResultTextBuilder::cellResultText( RimEclipseResultDefinition* eclRes
m_gridIndex, m_gridIndex,
porosityModel, porosityModel,
m_timeStepIndex, m_timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL" ) ); "SOIL" ) );
cvf::ref<RigResultAccessor> dataAccessObjectY = cvf::ref<RigResultAccessor> dataAccessObjectY =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
m_gridIndex, m_gridIndex,
porosityModel, porosityModel,
m_timeStepIndex, m_timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS" ) ); "SGAS" ) );
cvf::ref<RigResultAccessor> dataAccessObjectZ = cvf::ref<RigResultAccessor> dataAccessObjectZ =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
m_gridIndex, m_gridIndex,
porosityModel, porosityModel,
m_timeStepIndex, m_timeStepIndex,
RigEclipseResultAddress( RiaDefines::DYNAMIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT" ) ); "SWAT" ) );
double scalarValue = 0.0; double scalarValue = 0.0;