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-24 06:53:06 +02:00
parent 3f88fe197a
commit 83914006fd
64 changed files with 406 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp
View File

@ -85,7 +85,7 @@ void RiaCompletionTypeCalculationScheduler::scheduleRecalculateCompletionTypeAnd
if ( eclipseCase->eclipseCaseData() ) if ( eclipseCase->eclipseCaseData() )
{ {
eclipseCase->eclipseCaseData() eclipseCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->clearScalarResult( RiaDefines::ResultCatType::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

4
ApplicationCode/Application/RiaMemoryCleanup.cpp
View File

@ -79,7 +79,7 @@ void RiaMemoryCleanup::clearSelectedResultsFromMemory()
RimGeoMechCase* geoMechCase = dynamic_cast<RimGeoMechCase*>( m_case() ); RimGeoMechCase* geoMechCase = dynamic_cast<RimGeoMechCase*>( m_case() );
if ( eclipseCase ) if ( eclipseCase )
{ {
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( caseData ) if ( caseData )
{ {
std::vector<RigEclipseResultAddress> resultsToDelete = selectedEclipseResults(); std::vector<RigEclipseResultAddress> resultsToDelete = selectedEclipseResults();
@ -240,7 +240,7 @@ QList<caf::PdmOptionItemInfo> RiaMemoryCleanup::calculateValueOptions( const caf
if ( eclipseCase ) if ( eclipseCase )
{ {
std::set<RigEclipseResultAddress> resultsInUse = findEclipseResultsInUse(); std::set<RigEclipseResultAddress> resultsInUse = findEclipseResultsInUse();
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( caseData ) if ( caseData )
{ {
m_eclipseResultAddresses = caseData->existingResults(); m_eclipseResultAddresses = caseData->existingResults();

6
ApplicationCode/Application/RiaPorosityModel.cpp
View File

@ -25,9 +25,9 @@ namespace caf
template <> template <>
void caf::AppEnum<RiaDefines::PorosityModelType>::setUp() void caf::AppEnum<RiaDefines::PorosityModelType>::setUp()
{ {
addItem( RiaDefines::MATRIX_MODEL, "MATRIX_MODEL", "Matrix" ); addItem( RiaDefines::PorosityModelType::MATRIX_MODEL, "MATRIX_MODEL", "Matrix" );
addItem( RiaDefines::FRACTURE_MODEL, "FRACTURE_MODEL", "Fracture" ); addItem( RiaDefines::PorosityModelType::FRACTURE_MODEL, "FRACTURE_MODEL", "Fracture" );
setDefault( RiaDefines::MATRIX_MODEL ); setDefault( RiaDefines::PorosityModelType::MATRIX_MODEL );
} }
} // namespace caf } // namespace caf

2
ApplicationCode/Application/RiaPorosityModel.h
View File

@ -23,7 +23,7 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
namespace RiaDefines namespace RiaDefines
{ {
enum PorosityModelType enum class PorosityModelType
{ {
MATRIX_MODEL, MATRIX_MODEL,
FRACTURE_MODEL FRACTURE_MODEL

2
ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
View File

@ -86,7 +86,7 @@ caf::PdmScriptResponse RicfExportProperty::execute()
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( m_propertyName ) ) ) if ( !cellResultsData->ensureKnownResultLoaded( RigEclipseResultAddress( m_propertyName ) ) )
{ {

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

@ -148,7 +148,7 @@ std::vector<RigCompletionData>
return fractureCompletions; return fractureCompletions;
} }
auto cellResultsData = caseToApply->results( RiaDefines::MATRIX_MODEL ); auto cellResultsData = caseToApply->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !cellResultsData ) if ( !cellResultsData )
{ {
return fractureCompletions; return fractureCompletions;
@ -191,7 +191,7 @@ std::vector<RigCompletionData>
if ( pdParams.performScaling ) if ( pdParams.performScaling )
{ {
RigCaseCellResultsData* results = caseToApply->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* results = caseToApply->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
results->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) ); results->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) );
} }
@ -226,8 +226,9 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
double cDarcyInCorrectUnit = RiaEclipseUnitTools::darcysConstant( caseToApply->eclipseCaseData()->unitsType() ); double cDarcyInCorrectUnit = RiaEclipseUnitTools::darcysConstant( caseToApply->eclipseCaseData()->unitsType() );
const RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid(); const RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid();
const RigCaseCellResultsData* results = caseToApply->results( RiaDefines::MATRIX_MODEL ); const RigCaseCellResultsData* results = caseToApply->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
const RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
bool performPressureDepletionScaling = pdParams.performScaling; bool performPressureDepletionScaling = pdParams.performScaling;

2
ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
View File

@ -98,7 +98,7 @@ std::vector<RigCompletionData>
findFishboneImportedLateralsWellBoreParts( wellBorePartsInCells, wellPath, settings ); findFishboneImportedLateralsWellBoreParts( wellBorePartsInCells, wellPath, settings );
const RigActiveCellInfo* activeCellInfo = const RigActiveCellInfo* activeCellInfo =
settings.caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); settings.caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
for ( const auto& cellAndWellBoreParts : wellBorePartsInCells ) for ( const auto& cellAndWellBoreParts : wellBorePartsInCells )
{ {

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

@ -1163,7 +1163,7 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::gener
} }
const RigActiveCellInfo* activeCellInfo = const RigActiveCellInfo* activeCellInfo =
settings.caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); settings.caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( wellPath->perforationIntervalCollection()->isChecked() ) if ( wellPath->perforationIntervalCollection()->isChecked() )
{ {
@ -1285,30 +1285,30 @@ CellDirection RicWellPathExportCompletionDataFeatureImpl::calculateCellMainDirec
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) ); "DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) ); "DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) ); "DZ" ) );
@ -1347,58 +1347,58 @@ TransmissibilityData
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) ); "DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) ); "DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) ); "DZ" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMX" ) ); "PERMX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMY" ) ); "PERMY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMZ" ) ); "PERMZ" ) );
@ -1412,13 +1412,13 @@ TransmissibilityData
double ntg = 1.0; double ntg = 1.0;
{ {
// Trigger loading from file // Trigger loading from file
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"NTG" ) ); "NTG" ) );
@ -1504,12 +1504,12 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateDFactor( RimEclipseC
double porosity = 0.0; double porosity = 0.0;
{ {
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PORO" ) ); "PORO" ) );
@ -1548,70 +1548,70 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEc
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DX" ) ); "DX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DY" ) ); "DY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"DZ" ) ); "DZ" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMX" ) ); "PERMX" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMY" ) ); "PERMY" ) );
eclipseCase->results( RiaDefines::MATRIX_MODEL ) eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PERMZ" ) ); "PERMZ" ) );
double ntg = 1.0; double ntg = 1.0;
if ( eclipseCase->results( RiaDefines::MATRIX_MODEL ) if ( eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->ensureKnownResultLoaded( RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
0, 0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"NTG" ) ); "NTG" ) );
@ -1674,12 +1674,12 @@ std::pair<double, cvf::Vec2i>
const RimWellPath* wellPath, const RimWellPath* wellPath,
const QString& gridName ) const QString& gridName )
{ {
const RigEclipseCaseData* caseData = gridCase->eclipseCaseData(); const RigEclipseCaseData* caseData = gridCase->eclipseCaseData();
const RigMainGrid* mainGrid = caseData->mainGrid(); const RigMainGrid* mainGrid = caseData->mainGrid();
const RigActiveCellInfo* activeCellInfo = caseData->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo = caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry(); const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints(); const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints();
const std::vector<double>& mds = wellPathGeometry->measureDepths(); const std::vector<double>& mds = wellPathGeometry->measureDepths();
CVF_ASSERT( !coords.empty() && !mds.empty() ); CVF_ASSERT( !coords.empty() && !mds.empty() );
std::vector<WellPathCellIntersectionInfo> intersections = std::vector<WellPathCellIntersectionInfo> intersections =

17
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
View File

@ -926,8 +926,9 @@ RicMswExportInfo
const RimWellPath* wellPath, const RimWellPath* wellPath,
const std::vector<RimWellPathFracture*>& fractures ) const std::vector<RimWellPathFracture*>& fractures )
{ {
const RigMainGrid* grid = caseToApply->eclipseCaseData()->mainGrid(); const RigMainGrid* grid = caseToApply->eclipseCaseData()->mainGrid();
const RigActiveCellInfo* activeCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RiaEclipseUnitTools::UnitSystem unitSystem = caseToApply->eclipseCaseData()->unitsType(); RiaEclipseUnitTools::UnitSystem unitSystem = caseToApply->eclipseCaseData()->unitsType();
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry(); const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
@ -1087,10 +1088,11 @@ std::vector<SubSegmentIntersectionInfo>
const RimWellPath* wellPath, const RimWellPath* wellPath,
double& initialMD ) double& initialMD )
{ {
const RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo =
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry(); eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints(); const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
const std::vector<double>& mds = wellPathGeometry->measureDepths(); const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints();
const std::vector<double>& mds = wellPathGeometry->measureDepths();
CVF_ASSERT( !coords.empty() && !mds.empty() ); CVF_ASSERT( !coords.empty() && !mds.empty() );
std::vector<WellPathCellIntersectionInfo> intersections = std::vector<WellPathCellIntersectionInfo> intersections =
@ -1718,7 +1720,8 @@ std::vector<RigCompletionData>
RimEclipseCase* eclipseCase ) RimEclipseCase* eclipseCase )
{ {
std::vector<RigCompletionData> completionData; std::vector<RigCompletionData> completionData;
const RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo =
eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( wellPath->perforationIntervalCollection()->isChecked() && perforationInterval->isChecked() && if ( wellPath->perforationIntervalCollection()->isChecked() && perforationInterval->isChecked() &&
perforationInterval->isActiveOnDate( eclipseCase->timeStepDates()[timeStep] ) ) perforationInterval->isActiveOnDate( eclipseCase->timeStepDates()[timeStep] ) )

2
ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp
View File

@ -264,7 +264,7 @@ RigActiveCellInfo* RicCellRangeUi::activeCellInfo() const
RimEclipseCase* rimEclipeCase = dynamic_cast<RimEclipseCase*>( m_case() ); RimEclipseCase* rimEclipeCase = dynamic_cast<RimEclipseCase*>( m_case() );
if ( rimEclipeCase && rimEclipeCase->eclipseCaseData() ) if ( rimEclipeCase && rimEclipeCase->eclipseCaseData() )
{ {
return rimEclipeCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); return rimEclipeCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
} }
return nullptr; return nullptr;

2
ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp
View File

@ -48,7 +48,7 @@ bool RicEclipseCellResultToFileImpl::writePropertyToTextFile( const QString&
cvf::ref<RigResultAccessor> resultAccessor = cvf::ref<RigResultAccessor> resultAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCase, RigResultAccessorFactory::createFromResultAddress( eclipseCase,
0, 0,
RiaDefines::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStep, timeStep,
RigEclipseResultAddress( resultName ) ); RigEclipseResultAddress( resultName ) );
if ( resultAccessor.isNull() ) if ( resultAccessor.isNull() )

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

@ -166,7 +166,7 @@ void RicExportEclipseSectorModelUi::setCaseData( RigEclipseCaseData* caseData /*
for ( QString keyword : mainKeywords() ) for ( QString keyword : mainKeywords() )
{ {
if ( caseData && if ( caseData &&
caseData->results( RiaDefines::MATRIX_MODEL ) caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) ) ->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) )
{ {
selectedKeywords.v().push_back( keyword ); selectedKeywords.v().push_back( keyword );
@ -179,7 +179,7 @@ void RicExportEclipseSectorModelUi::setCaseData( RigEclipseCaseData* caseData /*
for ( QString keyword : selectedKeywords() ) for ( QString keyword : selectedKeywords() )
{ {
if ( caseData && if ( caseData &&
caseData->results( RiaDefines::MATRIX_MODEL ) caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) ) ->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, keyword ) ) )
{ {
validSelectedKeywords.push_back( keyword ); validSelectedKeywords.push_back( keyword );
@ -439,7 +439,7 @@ QList<caf::PdmOptionItemInfo>
QList<caf::PdmOptionItemInfo> options; QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &selectedKeywords ) if ( fieldNeedingOptions == &selectedKeywords )
{ {
RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
QList<caf::PdmOptionItemInfo> allOptions = QList<caf::PdmOptionItemInfo> allOptions =
RimEclipseResultDefinition::calcOptionsForVariableUiFieldStandard( RiaDefines::ResultCatType::STATIC_NATIVE, RimEclipseResultDefinition::calcOptionsForVariableUiFieldStandard( RiaDefines::ResultCatType::STATIC_NATIVE,
resultData ); resultData );
@ -561,7 +561,7 @@ void RicExportEclipseSectorModelUi::applyBoundaryDefaults()
if ( exportGridBox == ACTIVE_CELLS_BOX ) if ( exportGridBox == ACTIVE_CELLS_BOX )
{ {
cvf::Vec3st minActive, maxActive; cvf::Vec3st minActive, maxActive;
m_caseData->activeCellInfo( RiaDefines::MATRIX_MODEL )->IJKBoundingBox( minActive, maxActive ); m_caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->IJKBoundingBox( minActive, maxActive );
setMin( cvf::Vec3i( minActive ) ); setMin( cvf::Vec3i( minActive ) );
setMax( cvf::Vec3i( maxActive ) ); setMax( cvf::Vec3i( maxActive ) );
} }
@ -604,7 +604,7 @@ void RicExportEclipseSectorModelUi::applyBoundaryDefaults()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::removeInvalidKeywords() void RicExportEclipseSectorModelUi::removeInvalidKeywords()
{ {
RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = m_caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::vector<QString> validKeywords; std::vector<QString> validKeywords;
for ( QString keyword : selectedKeywords() ) for ( QString keyword : selectedKeywords() )

3
ApplicationCode/Commands/ExportCommands/RicSaveEclipseInputVisibleCellsFeature.cpp
View File

@ -76,7 +76,8 @@ void RicSaveEclipseInputVisibleCellsFeature::executeCommand( RimEclipseView*
std::vector<double> values; std::vector<double> values;
cvf::UByteArray visibleCells; cvf::UByteArray visibleCells;
view->calculateCurrentTotalCellVisibility( &visibleCells, view->currentTimeStep() ); view->calculateCurrentTotalCellVisibility( &visibleCells, view->currentTimeStep() );
RigActiveCellInfo* activeCellInfo = view->eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo =
view->eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
values.resize( visibleCells.size() ); values.resize( visibleCells.size() );
for ( size_t i = 0; i < visibleCells.size(); ++i ) for ( size_t i = 0; i < visibleCells.size(); ++i )
{ {

2
ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesFeature.cpp
View File

@ -72,7 +72,7 @@ std::pair<cvf::Vec3st, cvf::Vec3st> RicCreateMultipleFracturesFeature::ijkRangeF
cvf::Vec3st maxIJK; cvf::Vec3st maxIJK;
if ( gridCase && gridCase->eclipseCaseData() ) if ( gridCase && gridCase->eclipseCaseData() )
{ {
gridCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL )->IJKBoundingBox( minIJK, maxIJK ); gridCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->IJKBoundingBox( minIJK, maxIJK );
return std::make_pair( minIJK, maxIJK ); return std::make_pair( minIJK, maxIJK );
} }
return std::make_pair( cvf::Vec3st(), cvf::Vec3st() ); return std::make_pair( cvf::Vec3st(), cvf::Vec3st() );

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

@ -75,9 +75,9 @@ std::vector<RimSaturationPressurePlot*>
return plots; return plots;
} }
if ( eclipseCaseData && eclipseCaseData->results( RiaDefines::MATRIX_MODEL ) ) if ( eclipseCaseData && eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
RigCaseCellResultsData* resultData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !resultData->hasResultEntry( if ( !resultData->hasResultEntry(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) ) ) RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" ) ) )

17
ApplicationCode/Commands/RicCreateTemporaryLgrFeature.cpp
View File

@ -83,9 +83,10 @@ void RicCreateTemporaryLgrFeature::createLgrsForWellPaths( std::vector<RimWellPa
const std::set<RigCompletionData::CompletionType>& completionTypes, const std::set<RigCompletionData::CompletionType>& completionTypes,
QStringList* wellsIntersectingOtherLgrs ) QStringList* wellsIntersectingOtherLgrs )
{ {
auto eclipseCaseData = eclipseCase->eclipseCaseData(); auto eclipseCaseData = eclipseCase->eclipseCaseData();
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::FRACTURE_MODEL ); RigActiveCellInfo* fractureActiveCellInfo =
eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
auto lgrs = RicExportLgrFeature::buildLgrsForWellPaths( wellPaths, auto lgrs = RicExportLgrFeature::buildLgrsForWellPaths( wellPaths,
eclipseCase, eclipseCase,
@ -302,13 +303,14 @@ void RicCreateTemporaryLgrFeature::deleteAllCachedData( RimEclipseCase* eclipseC
{ {
if ( eclipseCase ) if ( eclipseCase )
{ {
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( cellResultsDataMatrix ) if ( cellResultsDataMatrix )
{ {
cellResultsDataMatrix->freeAllocatedResultsData(); cellResultsDataMatrix->freeAllocatedResultsData();
} }
RigCaseCellResultsData* cellResultsDataFracture = eclipseCase->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* cellResultsDataFracture =
eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( cellResultsDataFracture ) if ( cellResultsDataFracture )
{ {
cellResultsDataFracture->freeAllocatedResultsData(); cellResultsDataFracture->freeAllocatedResultsData();
@ -330,8 +332,9 @@ void RicCreateTemporaryLgrFeature::computeCachedData( RimEclipseCase* eclipseCas
{ {
if ( eclipseCase ) if ( eclipseCase )
{ {
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigCaseCellResultsData* cellResultsDataFracture = eclipseCase->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* cellResultsDataFracture =
eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
if ( eclipseCaseData ) if ( eclipseCaseData )

8
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -469,9 +469,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
{ {
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom ) for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{ {
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) && if ( !( eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclCase->eclipseCaseData() eclCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultInfo( cellResAddr.eclipseResultAddress ) ) ) ->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{ {
RiaLogging::warning( "Could not find a restart result property with name: \"" + RiaLogging::warning( "Could not find a restart result property with name: \"" +
@ -525,9 +525,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
std::vector<RimGridTimeHistoryCurve*> createdCurves; std::vector<RimGridTimeHistoryCurve*> createdCurves;
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom ) for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{ {
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) && if ( !( eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclCase->eclipseCaseData() eclCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultInfo( cellResAddr.eclipseResultAddress ) ) ) ->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{ {
RiaLogging::warning( "Could not find a restart result property with name: \"" + RiaLogging::warning( "Could not find a restart result property with name: \"" +

17
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -272,7 +272,7 @@ bool RifEclipseInputFileTools::exportGrid( const QString& fileName,
return false; return false;
} }
const RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
CVF_ASSERT( activeCellInfo ); CVF_ASSERT( activeCellInfo );
@ -446,7 +446,7 @@ bool RifEclipseInputFileTools::exportKeywords( const QString& resul
{ {
return false; return false;
} }
RigCaseCellResultsData* cellResultsData = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResultsData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* activeCells = cellResultsData->activeCellInfo(); RigActiveCellInfo* activeCells = cellResultsData->activeCellInfo();
RigMainGrid* mainGrid = eclipseCase->mainGrid(); RigMainGrid* mainGrid = eclipseCase->mainGrid();
@ -802,7 +802,7 @@ std::map<QString, QString> RifEclipseInputFileTools::readProperties( const QStri
if ( eclipseKeywordData ) if ( eclipseKeywordData )
{ {
QString newResultName = QString newResultName =
caseData->results( RiaDefines::MATRIX_MODEL )->makeResultNameUnique( fileKeywords[i].keyword ); caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->makeResultNameUnique( fileKeywords[i].keyword );
QString errMsg; QString errMsg;
if ( readDataFromKeyword( eclipseKeywordData, caseData, newResultName, &errMsg ) ) if ( readDataFromKeyword( eclipseKeywordData, caseData, newResultName, &errMsg ) )
{ {
@ -896,10 +896,12 @@ bool RifEclipseInputFileTools::readDataFromKeyword( ecl_kw_type* eclipseK
scalarValueCount = caseData->mainGrid()->globalCellArray().size(); scalarValueCount = caseData->mainGrid()->globalCellArray().size();
} }
else if ( keywordItemCount == caseData->activeCellInfo( RiaDefines::MATRIX_MODEL )->reservoirActiveCellCount() ) else if ( keywordItemCount ==
caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->reservoirActiveCellCount() )
{ {
mathingItemCount = true; mathingItemCount = true;
scalarValueCount = caseData->activeCellInfo( RiaDefines::MATRIX_MODEL )->reservoirActiveCellCount(); scalarValueCount =
caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->reservoirActiveCellCount();
} }
if ( !mathingItemCount ) if ( !mathingItemCount )
@ -911,9 +913,10 @@ bool RifEclipseInputFileTools::readDataFromKeyword( ecl_kw_type* eclipseK
} }
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName );
caseData->results( RiaDefines::MATRIX_MODEL )->createResultEntry( resAddr, false ); caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false );
auto newPropertyData = caseData->results( RiaDefines::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr ); auto newPropertyData =
caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
newPropertyData->push_back( std::vector<double>() ); newPropertyData->push_back( std::vector<double>() );
newPropertyData->at( 0 ).resize( scalarValueCount, HUGE_VAL ); newPropertyData->at( 0 ).resize( scalarValueCount, HUGE_VAL );

3
ApplicationCode/FileInterface/RifEclipseInputPropertyLoader.cpp
View File

@ -211,7 +211,8 @@ void RifEclipseInputPropertyLoader::readInputPropertiesForRemainingKeywords( Rim
{ {
for ( const QString& fileKeyword : *fileKeywordSet ) for ( const QString& fileKeyword : *fileKeywordSet )
{ {
QString resultName = eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->makeResultNameUnique( fileKeyword ); QString resultName =
eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->makeResultNameUnique( fileKeyword );
if ( RifEclipseInputFileTools::readProperty( filename, eclipseCaseData, fileKeyword, resultName ) ) if ( RifEclipseInputFileTools::readProperty( filename, eclipseCaseData, fileKeyword, resultName ) )
{ {
RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty; RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty;

58
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -258,8 +258,9 @@ bool RifReaderEclipseOutput::transferGeometry( const ecl_grid_type* mainEclGrid,
return false; return false;
} }
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ); RigActiveCellInfo* fractureActiveCellInfo =
eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
CVF_ASSERT( activeCellInfo && fractureActiveCellInfo ); CVF_ASSERT( activeCellInfo && fractureActiveCellInfo );
@ -453,7 +454,7 @@ bool RifReaderEclipseOutput::open( const QString& fileName, RigEclipseCaseData*
} }
// This test should probably be improved to test more directly for presence of NNC data // This test should probably be improved to test more directly for presence of NNC data
if ( m_eclipseCase->results( RiaDefines::MATRIX_MODEL )->hasFlowDiagUsableFluxes() ) if ( m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->hasFlowDiagUsableFluxes() )
{ {
auto subNncTask = nncProgress.task( "Reading dynamic NNC data" ); auto subNncTask = nncProgress.task( "Reading dynamic NNC data" );
transferDynamicNNCData( mainEclGrid, eclipseCase->mainGrid() ); transferDynamicNNCData( mainEclGrid, eclipseCase->mainGrid() );
@ -493,7 +494,7 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
{ {
CVF_ASSERT( m_eclipseCase ); CVF_ASSERT( m_eclipseCase );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
CVF_ASSERT( matrixModelResults ); CVF_ASSERT( matrixModelResults );
if ( fileName.isEmpty() ) if ( fileName.isEmpty() )
@ -877,8 +878,9 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
return false; return false;
} }
RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ); RigActiveCellInfo* fractureActiveCellInfo =
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
activeCellInfo->setReservoirCellCount( reservoirCellCount ); activeCellInfo->setReservoirCellCount( reservoirCellCount );
fractureActiveCellInfo->setReservoirCellCount( reservoirCellCount ); fractureActiveCellInfo->setReservoirCellCount( reservoirCellCount );
@ -935,8 +937,8 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
progInfo.setNextProgressIncrement( m_filesWithSameBaseName.size() ); progInfo.setNextProgressIncrement( m_filesWithSameBaseName.size() );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
std::vector<RigEclipseTimeStepInfo> timeStepInfos; std::vector<RigEclipseTimeStepInfo> timeStepInfos;
@ -958,9 +960,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList matrixResultNames = QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames, validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
m_dynamicResultsAccess->timeStepCount() ); m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < matrixResultNames.size(); ++i ) for ( int i = 0; i < matrixResultNames.size(); ++i )
@ -975,9 +977,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList fractureResultNames = QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames, validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL, RiaDefines::PorosityModelType::FRACTURE_MODEL,
m_dynamicResultsAccess->timeStepCount() ); m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < fractureResultNames.size(); ++i ) for ( int i = 0; i < fractureResultNames.size(); ++i )
@ -1049,9 +1051,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList matrixResultNames = QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames, validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
1 ); 1 );
// Add ACTNUM // Add ACTNUM
@ -1069,9 +1071,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList fractureResultNames = QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames, validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ), m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL, RiaDefines::PorosityModelType::FRACTURE_MODEL,
1 ); 1 );
// Add ACTNUM // Add ACTNUM
fractureResultNames += "ACTNUM"; fractureResultNames += "ACTNUM";
@ -1153,7 +1155,7 @@ void RifReaderEclipseOutput::sourSimRlResult( const QString& result, size_t step
size_t activeCellCount = cvf::UNDEFINED_SIZE_T; size_t activeCellCount = cvf::UNDEFINED_SIZE_T;
{ {
RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
fracActCellInfo->gridActiveCellCounts( 0, activeCellCount ); fracActCellInfo->gridActiveCellCounts( 0, activeCellCount );
} }
@ -2161,7 +2163,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
return QStringList(); return QStringList();
} }
if ( porosityModel == RiaDefines::FRACTURE_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL )
{ {
if ( fractureActiveCellInfo->reservoirActiveCellCount() == 0 ) if ( fractureActiveCellInfo->reservoirActiveCellCount() == 0 )
{ {
@ -2199,7 +2201,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
fractureActiveCellInfo->reservoirActiveCellCount(); fractureActiveCellInfo->reservoirActiveCellCount();
size_t timeStepsMatrixAndFractureRest = keywordDataItemCount % sumFractureMatrixActiveCellCount; size_t timeStepsMatrixAndFractureRest = keywordDataItemCount % sumFractureMatrixActiveCellCount;
if ( porosityModel == RiaDefines::MATRIX_MODEL && timeStepsMatrixRest == 0 ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL && timeStepsMatrixRest == 0 )
{ {
if ( keywordDataItemCount <= timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(), if ( keywordDataItemCount <= timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(),
sumFractureMatrixActiveCellCount ) ) sumFractureMatrixActiveCellCount ) )
@ -2207,7 +2209,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
validKeyword = true; validKeyword = true;
} }
} }
else if ( porosityModel == RiaDefines::FRACTURE_MODEL && else if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 ) fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 )
{ {
if ( keywordDataItemCount <= timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(), if ( keywordDataItemCount <= timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(),
@ -2363,9 +2365,9 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
{ {
if ( sourceResultValues.size() == 0 ) return; if ( sourceResultValues.size() == 0 ) return;
RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ); RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( matrixOrFracture == RiaDefines::MATRIX_MODEL && fracActCellInfo->reservoirActiveCellCount() == 0 ) if ( matrixOrFracture == RiaDefines::PorosityModelType::MATRIX_MODEL && fracActCellInfo->reservoirActiveCellCount() == 0 )
{ {
destinationResultValues->insert( destinationResultValues->end(), destinationResultValues->insert( destinationResultValues->end(),
sourceResultValues.begin(), sourceResultValues.begin(),
@ -2373,7 +2375,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
} }
else else
{ {
RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t sourceStartPosition = 0; size_t sourceStartPosition = 0;
@ -2387,7 +2389,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
actCellInfo->gridActiveCellCounts( i, matrixActiveCellCount ); actCellInfo->gridActiveCellCounts( i, matrixActiveCellCount );
fracActCellInfo->gridActiveCellCounts( i, fractureActiveCellCount ); fracActCellInfo->gridActiveCellCounts( i, fractureActiveCellCount );
if ( matrixOrFracture == RiaDefines::MATRIX_MODEL ) if ( matrixOrFracture == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
destinationResultValues->insert( destinationResultValues->end(), destinationResultValues->insert( destinationResultValues->end(),
sourceResultValues.begin() + sourceStartPosition, sourceResultValues.begin() + sourceStartPosition,

2
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@ -33,7 +33,7 @@ bool RifReaderMockModel::open( const QString& fileName, RigEclipseCaseData* ecli
m_reservoir = eclipseCase; m_reservoir = eclipseCase;
RigCaseCellResultsData* cellResults = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* cellResults = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::vector<RigEclipseTimeStepInfo> timeStepInfos; std::vector<RigEclipseTimeStepInfo> timeStepInfos;
{ {

6
ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
View File

@ -438,7 +438,9 @@ grpc::Status RiaGrpcCaseService::GetDaysSinceStart( grpc::ServerContext* con
RigEclipseResultAddress addrToMaxTimeStepCountResult; RigEclipseResultAddress addrToMaxTimeStepCountResult;
if ( eclipseCase && eclipseCase->eclipseCaseData() ) if ( eclipseCase && eclipseCase->eclipseCaseData() )
{ {
eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount( &addrToMaxTimeStepCountResult ); eclipseCase->eclipseCaseData()
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->maxTimeStepCount( &addrToMaxTimeStepCountResult );
if ( !addrToMaxTimeStepCountResult.isValid() ) if ( !addrToMaxTimeStepCountResult.isValid() )
{ {
return grpc::Status( grpc::NOT_FOUND, "Invalid result. No time steps found." ); return grpc::Status( grpc::NOT_FOUND, "Invalid result. No time steps found." );
@ -446,7 +448,7 @@ grpc::Status RiaGrpcCaseService::GetDaysSinceStart( grpc::ServerContext* con
} }
std::vector<double> daysSinceSimulationStart = eclipseCase->eclipseCaseData() std::vector<double> daysSinceSimulationStart = eclipseCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->daysSinceSimulationStart( addrToMaxTimeStepCountResult ); ->daysSinceSimulationStart( addrToMaxTimeStepCountResult );
for ( auto days : daysSinceSimulationStart ) for ( auto days : daysSinceSimulationStart )

2
ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
View File

@ -60,7 +60,7 @@ public:
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RiaCellResultsStateHandler( bool clientStreamer = false ) RiaCellResultsStateHandler( bool clientStreamer = false )
: m_eclipseCase( nullptr ) : m_eclipseCase( nullptr )
, m_porosityModel( RiaDefines::MATRIX_MODEL ) , m_porosityModel( RiaDefines::PorosityModelType::MATRIX_MODEL )
, m_streamedValueCount( 0u ) , m_streamedValueCount( 0u )
, m_cellCount( 0u ) , m_cellCount( 0u )
, m_clientStreamer( clientStreamer ) , m_clientStreamer( clientStreamer )

4
ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
View File

@ -126,8 +126,8 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
resultAddresses.push_back( addresses[2] ); resultAddresses.push_back( addresses[2] );
} }
RigCaseCellResultsData* resultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultsData = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
const cvf::Vec3d offset = eclipseCase->mainGrid()->displayModelOffset(); const cvf::Vec3d offset = eclipseCase->mainGrid()->displayModelOffset();

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

@ -673,14 +673,15 @@ void RimFlowCharacteristicsPlot::onLoadDataAndUpdate()
if ( m_cellFilter() == RigFlowDiagResults::CELLS_VISIBLE ) if ( m_cellFilter() == RigFlowDiagResults::CELLS_VISIBLE )
{ {
cvf::UByteArray visibleCells; cvf::UByteArray visibleCells;
m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( m_cellFilterView ) if ( m_cellFilterView )
{ {
m_cellFilterView()->calculateCurrentTotalCellVisibility( &visibleCells, timeStepIdx ); m_cellFilterView()->calculateCurrentTotalCellVisibility( &visibleCells, timeStepIdx );
} }
RigActiveCellInfo* activeCellInfo = m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo =
m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::vector<char> visibleActiveCells( activeCellInfo->reservoirActiveCellCount(), 0 ); std::vector<char> visibleActiveCells( activeCellInfo->reservoirActiveCellCount(), 0 );
for ( size_t i = 0; i < visibleCells.size(); ++i ) for ( size_t i = 0; i < visibleCells.size(); ++i )

13
ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
View File

@ -105,7 +105,8 @@ RigFlowDiagResults* RimFlowDiagSolution::flowDiagResults()
CVF_ASSERT( eclCase && eclCase->eclipseCaseData() ); CVF_ASSERT( eclCase && eclCase->eclipseCaseData() );
timeStepCount = eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount(); timeStepCount =
eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
} }
m_flowDiagResults = new RigFlowDiagResults( this, timeStepCount ); m_flowDiagResults = new RigFlowDiagResults( this, timeStepCount );
@ -167,11 +168,11 @@ std::map<std::string, std::vector<int>> RimFlowDiagSolution::allTracerActiveCell
if ( eclCase && eclCase->eclipseCaseData() ) if ( eclCase && eclCase->eclipseCaseData() )
{ {
const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid(); RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid();
RigActiveCellInfo* activeCellInfo = RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(
eclCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); // Todo: Must come from the results RiaDefines::PorosityModelType::MATRIX_MODEL ); // Todo: Must come from the results
// definition // definition
for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {

3
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -262,7 +262,8 @@ void RimWellAllocationPlot::updateFromWell()
( simWellData->wellProductionType( m_timeStep ) == RigWellResultFrame::PRODUCER || ( simWellData->wellProductionType( m_timeStep ) == RigWellResultFrame::PRODUCER ||
simWellData->wellProductionType( m_timeStep ) == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ); simWellData->wellProductionType( m_timeStep ) == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE );
RigEclCellIndexCalculator cellIdxCalc( m_case->eclipseCaseData()->mainGrid(), RigEclCellIndexCalculator cellIdxCalc( m_case->eclipseCaseData()->mainGrid(),
m_case->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ) ); m_case->eclipseCaseData()->activeCellInfo(
RiaDefines::PorosityModelType::MATRIX_MODEL ) );
wfCalculator.reset( new RigAccWellFlowCalculator( pipeBranchesCLCoords, wfCalculator.reset( new RigAccWellFlowCalculator( pipeBranchesCLCoords,
pipeBranchesCellIds, pipeBranchesCellIds,
tracerFractionCellValues, tracerFractionCellValues,

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

@ -115,7 +115,7 @@ 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::PorosityModelType::MATRIX_MODEL )
->hasResultEntry( ->hasResultEntry(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, pressureDataName ) ) ) RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, pressureDataName ) ) )
{ {
@ -233,7 +233,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::PorosityModelType::MATRIX_MODEL )
->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, channelName ) ) ) ->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, channelName ) ) )
{ {
return true; return true;
@ -502,7 +502,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::timeStep
if ( resultDataInfo.first.isValid() ) if ( resultDataInfo.first.isValid() )
{ {
for ( const QDateTime& timeStep : for ( const QDateTime& timeStep :
eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->timeStepDates( resultDataInfo.first ) ) eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates( resultDataInfo.first ) )
{ {
if ( timeStepsMap.count( timeStep ) == 0 ) if ( timeStepsMap.count( timeStep ) == 0 )
{ {
@ -556,8 +556,9 @@ std::set<QDateTime> RimWellPlotTools::availableSimWellTimesteps( RimEclipseCase*
{ {
std::set<QDateTime> availebleTimeSteps; std::set<QDateTime> availebleTimeSteps;
std::vector<QDateTime> allTimeSteps = eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->timeStepDates(); std::vector<QDateTime> allTimeSteps =
const RigSimWellData* simWell = eclCase->eclipseCaseData()->findSimWellData( simWellName ); eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
const RigSimWellData* simWell = eclCase->eclipseCaseData()->findSimWellData( simWellName );
for ( size_t tsIdx = 0; tsIdx < allTimeSteps.size(); ++tsIdx ) for ( size_t tsIdx = 0; tsIdx < allTimeSteps.size(); ++tsIdx )
{ {

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

@ -402,7 +402,7 @@ public:
// Find timestep index from qdatetime // Find timestep index from qdatetime
const std::vector<QDateTime> timeSteps = const std::vector<QDateTime> timeSteps =
eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->timeStepDates(); eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
size_t tsIdx = timeSteps.size(); size_t tsIdx = timeSteps.size();
for ( tsIdx = 0; tsIdx < timeSteps.size(); ++tsIdx ) for ( tsIdx = 0; tsIdx < timeSteps.size(); ++tsIdx )
{ {

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

@ -610,7 +610,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
// Time step // Time step
std::vector<QDateTime> timeSteps = std::vector<QDateTime> timeSteps =
gridCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->timeStepDates(); gridCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
int currentTimeStepIndex = -1; int currentTimeStepIndex = -1;
for ( size_t tsIdx = 0; tsIdx < timeSteps.size(); ++tsIdx ) for ( size_t tsIdx = 0; tsIdx < timeSteps.size(); ++tsIdx )
{ {

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

@ -758,7 +758,7 @@ std::map<int, cvf::UByteArray> RimGridCrossPlotDataSet::calculateCellVisibility(
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
if ( eclipseCaseData ) if ( eclipseCaseData )
{ {
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( porosityModel ); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( porosityModel );
if ( cellResultsData ) if ( cellResultsData )

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

@ -63,7 +63,7 @@ std::vector<RimSaturationPressurePlot*>
RigEclipseCaseData* eclipseCaseData = eclipseResultCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseResultCase->eclipseCaseData();
if ( !eclipseCaseData ) return generatedPlots; if ( !eclipseCaseData ) return generatedPlots;
auto results = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); auto results = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::set<int> eqlnumRegionIdsFound; std::set<int> eqlnumRegionIdsFound;
{ {
@ -93,7 +93,7 @@ std::vector<RimSaturationPressurePlot*>
// As discussed with Liv Merete, it is not any use for creation of different plots for matrix/fracture. For // As discussed with Liv Merete, it is not any use for creation of different plots for matrix/fracture. For
// now, use hardcoded value for MATRIX // now, use hardcoded value for MATRIX
plot->assignCaseAndEquilibriumRegion( RiaDefines::MATRIX_MODEL, plot->assignCaseAndEquilibriumRegion( RiaDefines::PorosityModelType::MATRIX_MODEL,
eclipseResultCase, eclipseResultCase,
zeroBasedEquilibriumRegion, zeroBasedEquilibriumRegion,
timeStep ); timeStep );

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -591,11 +591,11 @@ QString Rim3dOverlayInfoConfig::caseInfoText( RimEclipseView* eclipseView )
size_t mxActCellCount = eclipseView->eclipseCase() size_t mxActCellCount = eclipseView->eclipseCase()
->eclipseCaseData() ->eclipseCaseData()
->activeCellInfo( RiaDefines::MATRIX_MODEL ) ->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )
->reservoirActiveCellCount(); ->reservoirActiveCellCount();
size_t frActCellCount = eclipseView->eclipseCase() size_t frActCellCount = eclipseView->eclipseCase()
->eclipseCaseData() ->eclipseCaseData()
->activeCellInfo( RiaDefines::FRACTURE_MODEL ) ->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->reservoirActiveCellCount(); ->reservoirActiveCellCount();
QString activeCellCountText; QString activeCellCountText;

26
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -608,7 +608,8 @@ void RimEclipseCase::computeCachedData()
{ {
auto task = pInf.task( "Calculating faults", 17 ); auto task = pInf.task( "Calculating faults", 17 );
rigEclipseCase->mainGrid()->calculateFaults( rigEclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ) ); rigEclipseCase->mainGrid()->calculateFaults(
rigEclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
} }
{ {
@ -697,8 +698,9 @@ void RimEclipseCase::setReservoirData( RigEclipseCaseData* eclipseCase )
m_rigEclipseCase = eclipseCase; m_rigEclipseCase = eclipseCase;
if ( this->eclipseCaseData() ) if ( this->eclipseCaseData() )
{ {
m_fractureModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL ) ); m_fractureModelResults()->setCellResults(
m_matrixModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) ); eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
m_matrixModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
} }
else else
{ {
@ -730,9 +732,9 @@ cvf::BoundingBox RimEclipseCase::reservoirBoundingBox()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::BoundingBox RimEclipseCase::activeCellsBoundingBox() const cvf::BoundingBox RimEclipseCase::activeCellsBoundingBox() const
{ {
if ( m_rigEclipseCase.notNull() && m_rigEclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ) ) if ( m_rigEclipseCase.notNull() && m_rigEclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
return m_rigEclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL )->geometryBoundingBox(); return m_rigEclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->geometryBoundingBox();
} }
else else
{ {
@ -801,7 +803,7 @@ const RigCaseCellResultsData* RimEclipseCase::results( RiaDefines::PorosityModel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel ) RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel )
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_matrixModelResults(); return m_matrixModelResults();
} }
@ -814,7 +816,7 @@ RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::Poro
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel ) const const RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel ) const
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_matrixModelResults(); return m_matrixModelResults();
} }
@ -885,7 +887,7 @@ bool RimEclipseCase::openReserviorCase()
if ( createPlaceholderEntries ) if ( createPlaceholderEntries )
{ {
{ {
RigCaseCellResultsData* results = this->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* results = this->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( results ) if ( results )
{ {
results->createPlaceholderResultEntries(); results->createPlaceholderResultEntries();
@ -927,7 +929,7 @@ bool RimEclipseCase::openReserviorCase()
} }
{ {
RigCaseCellResultsData* results = this->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* results = this->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( results ) if ( results )
{ {
results->createPlaceholderResultEntries(); results->createPlaceholderResultEntries();
@ -989,7 +991,7 @@ QStringList RimEclipseCase::timeStepStrings() const
{ {
QStringList stringList; QStringList stringList;
const RigCaseCellResultsData* cellResultData = results( RiaDefines::MATRIX_MODEL ); const RigCaseCellResultsData* cellResultData = results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( cellResultData ) if ( cellResultData )
{ {
int timeStepCount = static_cast<int>( cellResultData->maxTimeStepCount() ); int timeStepCount = static_cast<int>( cellResultData->maxTimeStepCount() );
@ -1055,9 +1057,9 @@ std::set<QString> RimEclipseCase::sortedSimWellNames() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<QDateTime> RimEclipseCase::timeStepDates() const std::vector<QDateTime> RimEclipseCase::timeStepDates() const
{ {
if ( results( RiaDefines::MATRIX_MODEL ) ) if ( results( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
return results( RiaDefines::MATRIX_MODEL )->timeStepDates(); return results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
} }
return std::vector<QDateTime>(); return std::vector<QDateTime>();
} }

3
ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
View File

@ -129,7 +129,8 @@ RigMainGrid* RimEclipseCaseCollection::registerCaseInGridCollection( RigEclipseC
// This is the first insertion of this grid, compute cached data // This is the first insertion of this grid, compute cached data
rigEclipseCase->mainGrid()->computeCachedData(); rigEclipseCase->mainGrid()->computeCachedData();
rigEclipseCase->mainGrid()->calculateFaults( rigEclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ) ); rigEclipseCase->mainGrid()->calculateFaults(
rigEclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
equalGrid = rigEclipseCase->mainGrid(); equalGrid = rigEclipseCase->mainGrid();
} }

7
ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

@ -179,7 +179,7 @@ std::vector<double> RimEclipseContourMapProjection::generateResults( int timeSte
{ {
if ( !cellColors->isTernarySaturationSelected() ) if ( !cellColors->isTernarySaturationSelected() )
{ {
RigCaseCellResultsData* resultData = eclipseCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::vector<double> gridResultValues; std::vector<double> gridResultValues;
if ( isColumnResult() ) if ( isColumnResult() )
{ {
@ -260,7 +260,7 @@ 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::PorosityModelType::MATRIX_MODEL );
bool hasPoroResult = bool hasPoroResult =
resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ) ); resultData->hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" ) );
bool hasNtgResult = bool hasNtgResult =
@ -476,7 +476,8 @@ double RimEclipseContourMapProjection::getParameterWeightForCell( size_t
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t RimEclipseContourMapProjection::gridResultIndex( size_t globalCellIdx ) const size_t RimEclipseContourMapProjection::gridResultIndex( size_t globalCellIdx ) const
{ {
const RigActiveCellInfo* activeCellInfo = eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo =
eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
return activeCellInfo->cellResultIndex( globalCellIdx ); return activeCellInfo->cellResultIndex( globalCellIdx );
} }

18
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@ -91,11 +91,11 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
if ( fileNames.contains( RiaDefines::mockModelBasicInputCase() ) ) if ( fileNames.contains( RiaDefines::mockModelBasicInputCase() ) )
{ {
cvf::ref<RifReaderInterface> readerInterface = this->createMockModel( fileNames[0] ); cvf::ref<RifReaderInterface> readerInterface = this->createMockModel( fileNames[0] );
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL )->computeDerivedData(); eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDerivedData();
eclipseCaseData()->activeCellInfo( RiaDefines::FRACTURE_MODEL )->computeDerivedData(); eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDerivedData();
QFileInfo gridFileName( fileNames[0] ); QFileInfo gridFileName( fileNames[0] );
QString caseName = gridFileName.completeBaseName(); QString caseName = gridFileName.completeBaseName();
@ -210,8 +210,8 @@ bool RimEclipseInputCase::openEclipseGridFile()
CVF_ASSERT( this->eclipseCaseData() ); CVF_ASSERT( this->eclipseCaseData() );
CVF_ASSERT( readerInterface.notNull() ); CVF_ASSERT( readerInterface.notNull() );
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
this->eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis ); this->eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
@ -222,11 +222,11 @@ bool RimEclipseInputCase::openEclipseGridFile()
RiaApplication* app = RiaApplication::instance(); RiaApplication* app = RiaApplication::instance();
if ( app->preferences()->autocomputeDepthRelatedProperties ) if ( app->preferences()->autocomputeDepthRelatedProperties )
{ {
results( RiaDefines::MATRIX_MODEL )->computeDepthRelatedResults(); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::FRACTURE_MODEL )->computeDepthRelatedResults(); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDepthRelatedResults();
} }
results( RiaDefines::MATRIX_MODEL )->computeCellVolumes(); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeCellVolumes();
return true; return true;
} }

6
ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
View File

@ -91,7 +91,8 @@ void RimEclipseInputProperty::fieldChangedByUi( const caf::PdmFieldHandle* chang
QString oldName = oldValue.toString(); QString oldName = oldValue.toString();
QString newName = newValue.toString(); QString newName = newValue.toString();
RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* matrixResults =
rimCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( matrixResults ) if ( matrixResults )
{ {
if ( matrixResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) ) if ( matrixResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) )
@ -100,7 +101,8 @@ void RimEclipseInputProperty::fieldChangedByUi( const caf::PdmFieldHandle* chang
} }
} }
RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* fracResults =
rimCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( fracResults ) if ( fracResults )
{ {
if ( fracResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) ) if ( fracResults->updateResultName( RiaDefines::ResultCatType::INPUT_PROPERTY, oldName, newName ) )

25
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -190,8 +190,8 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
readerInterface = readerEclipseOutput; readerInterface = readerEclipseOutput;
} }
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
progInfo.incrementProgress(); progInfo.incrementProgress();
@ -231,11 +231,11 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
RiaApplication* app = RiaApplication::instance(); RiaApplication* app = RiaApplication::instance();
if ( app->preferences()->autocomputeDepthRelatedProperties ) if ( app->preferences()->autocomputeDepthRelatedProperties )
{ {
results( RiaDefines::MATRIX_MODEL )->computeDepthRelatedResults(); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::FRACTURE_MODEL )->computeDepthRelatedResults(); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDepthRelatedResults();
} }
results( RiaDefines::MATRIX_MODEL )->computeCellVolumes(); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeCellVolumes();
return true; return true;
} }
@ -288,7 +288,8 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
CVF_ASSERT( mainEclipseCase && mainEclipseCase->mainGrid() ); CVF_ASSERT( mainEclipseCase && mainEclipseCase->mainGrid() );
eclipseCase->setMainGrid( mainEclipseCase->mainGrid() ); eclipseCase->setMainGrid( mainEclipseCase->mainGrid() );
std::vector<QDateTime> timeStepDates = mainEclipseCase->results( RiaDefines::MATRIX_MODEL )->timeStepDates(); std::vector<QDateTime> timeStepDates =
mainEclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
cvf::ref<RifReaderEclipseOutput> readerEclipseOutput = new RifReaderEclipseOutput; cvf::ref<RifReaderEclipseOutput> readerEclipseOutput = new RifReaderEclipseOutput;
if ( !readerEclipseOutput->openAndReadActiveCellData( gridFileName(), timeStepDates, eclipseCase.p() ) ) if ( !readerEclipseOutput->openAndReadActiveCellData( gridFileName(), timeStepDates, eclipseCase.p() ) )
{ {
@ -300,8 +301,8 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
readerInterface = readerEclipseOutput; readerInterface = readerEclipseOutput;
} }
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() ); results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
CVF_ASSERT( this->eclipseCaseData() ); CVF_ASSERT( this->eclipseCaseData() );
CVF_ASSERT( readerInterface.notNull() ); CVF_ASSERT( readerInterface.notNull() );
@ -318,9 +319,9 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEclipseResultCase::loadAndUpdateSourSimData() void RimEclipseResultCase::loadAndUpdateSourSimData()
{ {
if ( !results( RiaDefines::MATRIX_MODEL ) ) return; if ( !results( RiaDefines::PorosityModelType::MATRIX_MODEL ) ) return;
results( RiaDefines::MATRIX_MODEL )->setHdf5Filename( m_sourSimFileName().path() ); results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setHdf5Filename( m_sourSimFileName().path() );
if ( !hasSourSimFile() ) if ( !hasSourSimFile() )
{ {
@ -612,8 +613,8 @@ void RimEclipseResultCase::defineUiOrdering( QString uiConfigName, caf::PdmUiOrd
group->add( &m_flipXAxis ); group->add( &m_flipXAxis );
group->add( &m_flipYAxis ); group->add( &m_flipYAxis );
if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) && if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount() > 0 ) eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount() > 0 )
{ {
auto group1 = uiOrdering.addNewGroup( "Time Step Filter" ); auto group1 = uiOrdering.addNewGroup( "Time Step Filter" );
group1->setCollapsedByDefault( true ); group1->setCollapsedByDefault( true );

107
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -199,10 +199,10 @@ bool RimEclipseStatisticsCase::openEclipseGridFile()
eclipseCase->setMainGrid( mainGrid ); eclipseCase->setMainGrid( mainGrid );
eclipseCase->setActiveCellInfo( RiaDefines::MATRIX_MODEL, eclipseCase->setActiveCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::MATRIX_MODEL ) ); gridCaseGroup->unionOfActiveCells( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
eclipseCase->setActiveCellInfo( RiaDefines::FRACTURE_MODEL, eclipseCase->setActiveCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::FRACTURE_MODEL ) ); gridCaseGroup->unionOfActiveCells( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
this->setReservoirData( eclipseCase.p() ); this->setReservoirData( eclipseCase.p() );
@ -259,14 +259,14 @@ void RimEclipseStatisticsCase::computeStatistics()
std::vector<RimEclipseCase*> sourceCases = getSourceCases(); std::vector<RimEclipseCase*> sourceCases = getSourceCases();
if ( sourceCases.size() == 0 || !sourceCases.at( 0 )->results( RiaDefines::MATRIX_MODEL ) ) if ( sourceCases.size() == 0 || !sourceCases.at( 0 )->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
return; return;
} }
// The first source has been read completely from disk, and contains grid and meta data // The first source has been read completely from disk, and contains grid and meta data
// Use this information for all cases in the case group // Use this information for all cases in the case group
size_t timeStepCount = sourceCases.at( 0 )->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount(); size_t timeStepCount = sourceCases.at( 0 )->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
RimStatisticsConfig statisticsConfig; RimStatisticsConfig statisticsConfig;
@ -294,28 +294,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::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
m_selectedInputProperties()[pIdx] ) ); m_selectedInputProperties()[pIdx] ) );
} }
@ -323,7 +323,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureDynamicProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedFractureDynamicProperties().size(); ++pIdx )
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
m_selectedFractureDynamicProperties()[pIdx] ) ); m_selectedFractureDynamicProperties()[pIdx] ) );
} }
@ -331,7 +331,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureStaticProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedFractureStaticProperties().size(); ++pIdx )
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::ResultCatType::STATIC_NATIVE,
m_selectedFractureStaticProperties()[pIdx] ) ); m_selectedFractureStaticProperties()[pIdx] ) );
} }
@ -339,7 +339,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureGeneratedProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedFractureGeneratedProperties().size(); ++pIdx )
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::GENERATED, RiaDefines::ResultCatType::GENERATED,
m_selectedFractureGeneratedProperties()[pIdx] ) ); m_selectedFractureGeneratedProperties()[pIdx] ) );
} }
@ -347,7 +347,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureInputProperties().size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < m_selectedFractureInputProperties().size(); ++pIdx )
{ {
resultSpecification.append( resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL, RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::INPUT_PROPERTY, RiaDefines::ResultCatType::INPUT_PROPERTY,
m_selectedFractureInputProperties()[pIdx] ) ); m_selectedFractureInputProperties()[pIdx] ) );
} }
@ -489,50 +489,50 @@ QList<caf::PdmOptionItemInfo>
if ( &m_selectedDynamicProperties == fieldNeedingOptions ) if ( &m_selectedDynamicProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); ->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedStaticProperties == fieldNeedingOptions ) else if ( &m_selectedStaticProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE ); ->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedGeneratedProperties == fieldNeedingOptions ) else if ( &m_selectedGeneratedProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED ); caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedInputProperties == fieldNeedingOptions ) else if ( &m_selectedInputProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY ); ->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureDynamicProperties == fieldNeedingOptions ) else if ( &m_selectedFractureDynamicProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); ->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureStaticProperties == fieldNeedingOptions ) else if ( &m_selectedFractureStaticProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE ); ->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureGeneratedProperties == fieldNeedingOptions ) else if ( &m_selectedFractureGeneratedProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED ); ->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList ); return toOptionList( varList );
} }
else if ( &m_selectedFractureInputProperties == fieldNeedingOptions ) else if ( &m_selectedFractureInputProperties == fieldNeedingOptions )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY ); ->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList ); return toOptionList( varList );
} }
@ -725,29 +725,29 @@ 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 && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) ); m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedStaticProperties.uiCapability()->setUiHidden( m_selectedStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) ); m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedGeneratedProperties.uiCapability()->setUiHidden( m_selectedGeneratedProperties.uiCapability()->setUiHidden(
isLocked || isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
!( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) ); m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedInputProperties.uiCapability()->setUiHidden( m_selectedInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) ); m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
m_selectedFractureDynamicProperties.uiCapability()->setUiHidden( m_selectedFractureDynamicProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) ); m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedFractureStaticProperties.uiCapability()->setUiHidden( m_selectedFractureStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) ); m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden( m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden(
isLocked || isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
!( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) ); m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedFractureInputProperties.uiCapability()->setUiHidden( m_selectedFractureInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL && isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) ); m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
} }
@ -769,8 +769,9 @@ void RimEclipseStatisticsCase::updatePercentileUiVisibility()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseStatisticsCase::hasComputedStatistics() const bool RimEclipseStatisticsCase::hasComputedStatistics() const
{ {
if ( eclipseCaseData() && ( eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->existingResults().size() || if ( eclipseCaseData() &&
eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL )->existingResults().size() ) ) ( eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->existingResults().size() ||
eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->existingResults().size() ) )
{ {
return true; return true;
} }
@ -808,14 +809,14 @@ void RimEclipseStatisticsCase::updateConnectedEditorsAndReservoirViews()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEclipseStatisticsCase::clearComputedStatistics() void RimEclipseStatisticsCase::clearComputedStatistics()
{ {
if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) ) if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->clearAllResults(); eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->clearAllResults();
} }
if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL ) ) if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL ) )
{ {
eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL )->clearAllResults(); eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->clearAllResults();
} }
updateConnectedEditorsAndReservoirViews(); updateConnectedEditorsAndReservoirViews();
@ -853,32 +854,32 @@ void RimEclipseStatisticsCase::populateResultSelection()
if ( m_selectedDynamicProperties().size() == 0 ) if ( m_selectedDynamicProperties().size() == 0 )
{ {
QStringList varList = QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); ->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 = QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE ); ->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 = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); ->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 = QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE ); ->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" );
} }

8
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -50,9 +50,9 @@ void RimEclipseStatisticsCaseEvaluator::addNamedResult( RigCaseCellResultsData*
CVF_ASSERT( m_sourceCases.size() > 0 ); CVF_ASSERT( m_sourceCases.size() > 0 );
std::vector<RigEclipseResultAddress> resAddresses = std::vector<RigEclipseResultAddress> resAddresses =
m_sourceCases[0]->results( RiaDefines::MATRIX_MODEL )->existingResults(); m_sourceCases[0]->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->existingResults();
std::vector<RigEclipseTimeStepInfo> sourceTimeStepInfos = std::vector<RigEclipseTimeStepInfo> sourceTimeStepInfos =
m_sourceCases[0]->results( RiaDefines::MATRIX_MODEL )->timeStepInfos( resAddresses[0] ); m_sourceCases[0]->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepInfos( resAddresses[0] );
RigEclipseResultAddress resAddr( resultType, resultName ); RigEclipseResultAddress resAddr( resultType, resultName );
destinationCellResults->createResultEntry( resAddr, true ); destinationCellResults->createResultEntry( resAddr, true );
@ -346,8 +346,8 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults( const QList<ResSpec>
if ( !eclipseCase->reservoirViews.size() ) if ( !eclipseCase->reservoirViews.size() )
{ {
eclipseCase->results( RiaDefines::MATRIX_MODEL )->freeAllocatedResultsData(); eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->freeAllocatedResultsData();
eclipseCase->results( RiaDefines::FRACTURE_MODEL )->freeAllocatedResultsData(); eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->freeAllocatedResultsData();
} }
} }

2
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@ -63,7 +63,7 @@ public:
{ {
ResSpec() ResSpec()
: m_resType( RiaDefines::ResultCatType::DYNAMIC_NATIVE ) : m_resType( RiaDefines::ResultCatType::DYNAMIC_NATIVE )
, m_poroModel( RiaDefines::MATRIX_MODEL ) , m_poroModel( RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
} }
ResSpec( RiaDefines::PorosityModelType poroModel, RiaDefines::ResultCatType resType, QString resVarName ) ResSpec( RiaDefines::PorosityModelType poroModel, RiaDefines::ResultCatType resType, QString resVarName )

2
ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp
View File

@ -194,7 +194,7 @@ void RimElementVectorResult::mappingRange( double& min, double& max ) const
RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( view ); RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( view );
RigCaseCellResultsData* resultsData = RigCaseCellResultsData* resultsData =
eclipseView->eclipseCase()->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ); eclipseView->eclipseCase()->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
resultsData->ensureKnownResultLoaded( resVarAddr ); resultsData->ensureKnownResultLoaded( resVarAddr );

20
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -202,7 +202,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
RigEclipseCaseData* rigCaseData = mainCase->eclipseCaseData(); RigEclipseCaseData* rigCaseData = mainCase->eclipseCaseData();
CVF_ASSERT( rigCaseData ); CVF_ASSERT( rigCaseData );
RiaDefines::PorosityModelType poroModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType poroModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
mainCase->results( poroModel )->createPlaceholderResultEntries(); mainCase->results( poroModel )->createPlaceholderResultEntries();
// Action A : Read active cell info // Action A : Read active cell info
@ -234,8 +234,8 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
RimEclipseCase* rimReservoir = statisticsCaseCollection()->reservoirs[i]; RimEclipseCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
// Check if any results are stored in cache // Check if any results are stored in cache
if ( rimReservoir->resultsStorage( RiaDefines::MATRIX_MODEL )->storedResultsCount() > 0 || if ( rimReservoir->resultsStorage( RiaDefines::PorosityModelType::MATRIX_MODEL )->storedResultsCount() > 0 ||
rimReservoir->resultsStorage( RiaDefines::FRACTURE_MODEL )->storedResultsCount() > 0 ) rimReservoir->resultsStorage( RiaDefines::PorosityModelType::FRACTURE_MODEL )->storedResultsCount() > 0 )
{ {
foundResultsInCache = true; foundResultsInCache = true;
break; break;
@ -308,7 +308,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
{ {
if ( caseCollection->reservoirs[caseIdx] if ( caseCollection->reservoirs[caseIdx]
->eclipseCaseData() ->eclipseCaseData()
->activeCellInfo( RiaDefines::MATRIX_MODEL ) ->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )
->isActive( reservoirCellIndex ) ) ->isActive( reservoirCellIndex ) )
{ {
activeM[gridLocalCellIndex] = 1; activeM[gridLocalCellIndex] = 1;
@ -319,7 +319,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
{ {
if ( caseCollection->reservoirs[caseIdx] if ( caseCollection->reservoirs[caseIdx]
->eclipseCaseData() ->eclipseCaseData()
->activeCellInfo( RiaDefines::FRACTURE_MODEL ) ->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->isActive( reservoirCellIndex ) ) ->isActive( reservoirCellIndex ) )
{ {
activeF[gridLocalCellIndex] = 1; activeF[gridLocalCellIndex] = 1;
@ -405,13 +405,13 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
RimEclipseCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i]; RimEclipseCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
if ( !rimStaticsCase ) continue; if ( !rimStaticsCase ) continue;
if ( rimStaticsCase->results( RiaDefines::MATRIX_MODEL ) ) if ( rimStaticsCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) )
{ {
rimStaticsCase->results( RiaDefines::MATRIX_MODEL )->clearAllResults(); rimStaticsCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->clearAllResults();
} }
if ( rimStaticsCase->results( RiaDefines::FRACTURE_MODEL ) ) if ( rimStaticsCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL ) )
{ {
rimStaticsCase->results( RiaDefines::FRACTURE_MODEL )->clearAllResults(); rimStaticsCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->clearAllResults();
} }
for ( size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++ ) for ( size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++ )
@ -457,7 +457,7 @@ bool RimIdenticalGridCaseGroup::contains( RimEclipseCase* reservoir ) const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigActiveCellInfo* RimIdenticalGridCaseGroup::unionOfActiveCells( RiaDefines::PorosityModelType porosityType ) RigActiveCellInfo* RimIdenticalGridCaseGroup::unionOfActiveCells( RiaDefines::PorosityModelType porosityType )
{ {
if ( porosityType == RiaDefines::MATRIX_MODEL ) if ( porosityType == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_unionOfMatrixActiveCells.p(); return m_unionOfMatrixActiveCells.p();
} }

5
ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp
View File

@ -95,13 +95,14 @@ void RimReloadCaseTools::clearAllGridData( RigEclipseCaseData* eclipseCaseData )
{ {
if ( !eclipseCaseData ) return; if ( !eclipseCaseData ) return;
RigCaseCellResultsData* matrixModelResults = eclipseCaseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* matrixModelResults = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( matrixModelResults ) if ( matrixModelResults )
{ {
matrixModelResults->clearAllResults(); matrixModelResults->clearAllResults();
} }
RigCaseCellResultsData* fractureModelResults = eclipseCaseData->results( RiaDefines::FRACTURE_MODEL ); RigCaseCellResultsData* fractureModelResults =
eclipseCaseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( fractureModelResults ) if ( fractureModelResults )
{ {
fractureModelResults->clearAllResults(); fractureModelResults->clearAllResults();

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
View File

@ -345,7 +345,7 @@ void RimSummaryPlotFilterTextCurveSetEditor::fieldChangedByUi( const caf::PdmFie
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom ) for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{ {
RigCaseCellResultsData* gridCellResults = RigCaseCellResultsData* gridCellResults =
eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ); eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !( gridCellResults && gridCellResults->resultInfo( cellResAddr.eclipseResultAddress ) ) ) if ( !( gridCellResults && gridCellResults->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{ {
RiaLogging::warning( "Could not find a restart result property with name: \"" + RiaLogging::warning( "Could not find a restart result property with name: \"" +

4
ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
View File

@ -150,7 +150,7 @@ void RigEclipseToStimPlanCellTransmissibilityCalculator::calculateStimPlanCellsM
const RigEclipseCaseData* eclipseCaseData = m_case->eclipseCaseData(); const RigEclipseCaseData* eclipseCaseData = m_case->eclipseCaseData();
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
cvf::ref<RigResultAccessor> dataAccessObjectDx = createResultAccessor( m_case, "DX" ); cvf::ref<RigResultAccessor> dataAccessObjectDx = createResultAccessor( m_case, "DX" );
cvf::ref<RigResultAccessor> dataAccessObjectDy = createResultAccessor( m_case, "DY" ); cvf::ref<RigResultAccessor> dataAccessObjectDy = createResultAccessor( m_case, "DY" );
@ -380,7 +380,7 @@ cvf::ref<RigResultAccessor>
RigEclipseToStimPlanCellTransmissibilityCalculator::createResultAccessor( const RimEclipseCase* eclipseCase, RigEclipseToStimPlanCellTransmissibilityCalculator::createResultAccessor( const RimEclipseCase* eclipseCase,
const QString& uiResultName ) const QString& uiResultName )
{ {
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
const RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); const RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
// Create result accessor object for main grid at time step zero (static result date is always at first time step // Create result accessor object for main grid at time step zero (static result date is always at first time step

18
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -47,8 +47,8 @@ RigEclipseCaseData::RigEclipseCaseData( RimEclipseCase* ownerCase )
m_mainGrid = new RigMainGrid(); m_mainGrid = new RigMainGrid();
m_ownerCase = ownerCase; m_ownerCase = ownerCase;
m_matrixModelResults = new RigCaseCellResultsData( this, RiaDefines::MATRIX_MODEL ); m_matrixModelResults = new RigCaseCellResultsData( this, RiaDefines::PorosityModelType::MATRIX_MODEL );
m_fractureModelResults = new RigCaseCellResultsData( this, RiaDefines::FRACTURE_MODEL ); m_fractureModelResults = new RigCaseCellResultsData( this, RiaDefines::PorosityModelType::FRACTURE_MODEL );
m_activeCellInfo = new RigActiveCellInfo; m_activeCellInfo = new RigActiveCellInfo;
m_fractureActiveCellInfo = new RigActiveCellInfo; m_fractureActiveCellInfo = new RigActiveCellInfo;
@ -592,7 +592,7 @@ void RigEclipseCaseData::setEquilData( const std::vector<RigEquil>& equilObjects
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::PorosityModelType porosityModel ) RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::PorosityModelType porosityModel )
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_activeCellInfo.p(); return m_activeCellInfo.p();
} }
@ -605,7 +605,7 @@ RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::PorosityModel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::PorosityModelType porosityModel ) const const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::PorosityModelType porosityModel ) const
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_activeCellInfo.p(); return m_activeCellInfo.p();
} }
@ -618,7 +618,7 @@ const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo( RiaDefines::Porosit
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigEclipseCaseData::setActiveCellInfo( RiaDefines::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo ) void RigEclipseCaseData::setActiveCellInfo( RiaDefines::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo )
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
m_activeCellInfo = activeCellInfo; m_activeCellInfo = activeCellInfo;
m_matrixModelResults->setActiveCellInfo( m_activeCellInfo.p() ); m_matrixModelResults->setActiveCellInfo( m_activeCellInfo.p() );
@ -635,8 +635,8 @@ void RigEclipseCaseData::setActiveCellInfo( RiaDefines::PorosityModelType porosi
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigEclipseCaseData::hasFractureResults() const bool RigEclipseCaseData::hasFractureResults() const
{ {
if ( activeCellInfo( RiaDefines::FRACTURE_MODEL ) && if ( activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ) &&
activeCellInfo( RiaDefines::FRACTURE_MODEL )->reservoirActiveCellCount() > 0 ) activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL )->reservoirActiveCellCount() > 0 )
{ {
return true; return true;
} }
@ -738,7 +738,7 @@ RigAllenDiagramData* RigEclipseCaseData::allenDiagramData()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigCaseCellResultsData* RigEclipseCaseData::results( RiaDefines::PorosityModelType porosityModel ) RigCaseCellResultsData* RigEclipseCaseData::results( RiaDefines::PorosityModelType porosityModel )
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_matrixModelResults.p(); return m_matrixModelResults.p();
} }
@ -751,7 +751,7 @@ RigCaseCellResultsData* RigEclipseCaseData::results( RiaDefines::PorosityModelTy
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigCaseCellResultsData* RigEclipseCaseData::results( RiaDefines::PorosityModelType porosityModel ) const const RigCaseCellResultsData* RigEclipseCaseData::results( RiaDefines::PorosityModelType porosityModel ) const
{ {
if ( porosityModel == RiaDefines::MATRIX_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
return m_matrixModelResults.p(); return m_matrixModelResults.p();
} }

2
ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp
View File

@ -43,7 +43,7 @@ RigEclipseCrossPlotResult RigEclipseCrossPlotDataExtractor::extract( RigEclipseC
{ {
RigEclipseCrossPlotResult result; RigEclipseCrossPlotResult result;
RigCaseCellResultsData* resultData = caseData->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* resultData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !resultData ) return result; if ( !resultData ) return result;
const std::vector<std::vector<double>>* catValuesForAllSteps = nullptr; const std::vector<std::vector<double>>* catValuesForAllSteps = nullptr;

3
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
View File

@ -84,7 +84,8 @@ const RigActiveCellInfo* RigFlowDiagResults::activeCellInfo( const RigFlowDiagRe
RimEclipseResultCase* eclCase; RimEclipseResultCase* eclCase;
m_flowDiagSolution->firstAncestorOrThisOfType( eclCase ); m_flowDiagSolution->firstAncestorOrThisOfType( eclCase );
return eclCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); // Todo: base on resVarAddr member return eclCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ); // Todo: base on
// resVarAddr member
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

23
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@ -231,8 +231,9 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
{ {
using namespace Opm::FlowDiagnostics; using namespace Opm::FlowDiagnostics;
RigFlowDiagTimeStepResult result( RigFlowDiagTimeStepResult result( m_eclipseCase->eclipseCaseData()
m_eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL )->reservoirActiveCellCount() ); ->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )
->reservoirActiveCellCount() );
caf::ProgressInfo progressInfo( 8, "Calculating Flow Diagnostics" ); caf::ProgressInfo progressInfo( 8, "Calculating Flow Diagnostics" );
@ -282,7 +283,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
size_t restartFileCount = static_cast<size_t>( restartFileNames.size() ); size_t restartFileCount = static_cast<size_t>( restartFileNames.size() );
size_t maxTimeStepCount = size_t maxTimeStepCount =
m_eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount(); m_eclipseCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
if ( restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount ) if ( restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount )
{ {
@ -329,10 +330,12 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
CVF_ASSERT( currentRestartData ); CVF_ASSERT( currentRestartData );
RigEclipseResultAddress addrToMaxTimeStepCountResult; RigEclipseResultAddress addrToMaxTimeStepCountResult;
m_eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount( &addrToMaxTimeStepCountResult ); m_eclipseCase->eclipseCaseData()
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->maxTimeStepCount( &addrToMaxTimeStepCountResult );
int reportStepNumber = m_eclipseCase->eclipseCaseData() int reportStepNumber = m_eclipseCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->reportStepNumber( addrToMaxTimeStepCountResult, timeStepIndex ); ->reportStepNumber( addrToMaxTimeStepCountResult, timeStepIndex );
if ( !currentRestartData->selectReportStep( reportStepNumber ) ) if ( !currentRestartData->selectReportStep( reportStepNumber ) )
@ -349,7 +352,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
try try
{ {
if ( m_eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->hasFlowDiagUsableFluxes() ) if ( m_eclipseCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->hasFlowDiagUsableFluxes() )
{ {
Opm::FlowDiagnostics::ConnectionValues connectionsVals = Opm::FlowDiagnostics::ConnectionValues connectionsVals =
RigFlowDiagInterfaceTools::extractFluxFieldFromRestartFile( *( m_opmFlowDiagStaticData->m_eclGraph ), RigFlowDiagInterfaceTools::extractFluxFieldFromRestartFile( *( m_opmFlowDiagStaticData->m_eclGraph ),
@ -528,7 +531,7 @@ bool RigFlowDiagSolverInterface::ensureStaticDataObjectInstanceCreated()
return false; return false;
} }
auto fileReader = eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->readerInterface(); auto fileReader = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->readerInterface();
auto eclOutput = dynamic_cast<const RifReaderEclipseOutput*>( fileReader ); auto eclOutput = dynamic_cast<const RifReaderEclipseOutput*>( fileReader );
if ( eclOutput ) if ( eclOutput )
{ {
@ -562,19 +565,19 @@ void RigFlowDiagSolverInterface::assignPhaseCorrecedPORV( RigFlowDiagResultAddre
switch ( phaseSelection ) switch ( phaseSelection )
{ {
case RigFlowDiagResultAddress::PHASE_OIL: case RigFlowDiagResultAddress::PHASE_OIL:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL", "SOIL",
timeStepIdx ); timeStepIdx );
break; break;
case RigFlowDiagResultAddress::PHASE_GAS: case RigFlowDiagResultAddress::PHASE_GAS:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS", "SGAS",
timeStepIdx ); timeStepIdx );
break; break;
case RigFlowDiagResultAddress::PHASE_WAT: case RigFlowDiagResultAddress::PHASE_WAT:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT", "SWAT",
timeStepIdx ); timeStepIdx );

2
ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
View File

@ -118,7 +118,7 @@ void RigFlowDiagStatCalc::mobileVolumeWeightedMean( size_t timeStepIndex, double
m_resultsData->flowDiagSolution()->firstAncestorOrThisOfType( eclCase ); m_resultsData->flowDiagSolution()->firstAncestorOrThisOfType( eclCase );
if ( !eclCase ) return; if ( !eclCase ) return;
RigCaseCellResultsData* caseCellResultsData = eclCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* caseCellResultsData = eclCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigEclipseResultAddress mobPoreVolResAddr( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress mobPoreVolResAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::mobilePoreVolumeName() ); RiaDefines::mobilePoreVolumeName() );

2
ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
View File

@ -109,7 +109,7 @@ void RigFlowDiagVisibleCellsStatCalc::mobileVolumeWeightedMean( size_t timeStepI
m_resultsData->flowDiagSolution()->firstAncestorOrThisOfType( eclCase ); m_resultsData->flowDiagSolution()->firstAncestorOrThisOfType( eclCase );
if ( !eclCase ) return; if ( !eclCase ) return;
RigCaseCellResultsData* caseCellResultsData = eclCase->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* caseCellResultsData = eclCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigEclipseResultAddress mobPorvAddr( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName() ); RigEclipseResultAddress mobPorvAddr( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName() );

40
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -42,13 +42,15 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid(); RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid();
RigEclipseCaseData* eclipseCaseData = caseToApply->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = caseToApply->eclipseCaseData();
RigCaseCellResultsData* gridCellResults = caseToApply->results( RiaDefines::MATRIX_MODEL ); RigCaseCellResultsData* gridCellResults = caseToApply->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* actCellInfo =
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
size_t timeStepCount = caseToApply->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount(); size_t timeStepCount =
size_t totalProgress = tracerNames.size() + 8 + timeStepCount + 2 * timeStepCount; caseToApply->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
size_t totalProgress = tracerNames.size() + 8 + timeStepCount + 2 * timeStepCount;
caf::ProgressInfo progress( totalProgress, "Calculating number of flooded mobile pore volumes." ); caf::ProgressInfo progress( totalProgress, "Calculating number of flooded mobile pore volumes." );
progress.setProgressDescription( "Loading required results" ); progress.setProgressDescription( "Loading required results" );
// PORV // PORV
@ -110,7 +112,7 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
progress.incrementProgress(); progress.incrementProgress();
std::vector<double> daysSinceSimulationStart = std::vector<double> daysSinceSimulationStart =
caseToApply->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->daysSinceSimulationStart(); caseToApply->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->daysSinceSimulationStart();
progress.incrementProgress(); progress.incrementProgress();
@ -119,24 +121,24 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
const std::vector<double>* flowrateI = nullptr; const std::vector<double>* flowrateI = nullptr;
if ( hasFlowrateI ) if ( hasFlowrateI )
{ {
flowrateI = flowrateI = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatIAddr, timeStep ) ); ->cellScalarResults( flrWatIAddr, timeStep ) );
} }
flowrateIatAllTimeSteps.push_back( flowrateI ); flowrateIatAllTimeSteps.push_back( flowrateI );
const std::vector<double>* flowrateJ = nullptr; const std::vector<double>* flowrateJ = nullptr;
if ( hasFlowrateJ ) if ( hasFlowrateJ )
{ {
flowrateJ = flowrateJ = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatJAddr, timeStep ) ); ->cellScalarResults( flrWatJAddr, timeStep ) );
} }
flowrateJatAllTimeSteps.push_back( flowrateJ ); flowrateJatAllTimeSteps.push_back( flowrateJ );
const std::vector<double>* flowrateK = nullptr; const std::vector<double>* flowrateK = nullptr;
if ( hasFlowrateK ) if ( hasFlowrateK )
{ {
flowrateK = flowrateK = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatKAddr, timeStep ) ); ->cellScalarResults( flrWatKAddr, timeStep ) );
} }
flowrateKatAllTimeSteps.push_back( flowrateK ); flowrateKatAllTimeSteps.push_back( flowrateK );
@ -150,7 +152,8 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
for ( const RigEclipseResultAddress& tracerResAddr : tracerResAddrs ) for ( const RigEclipseResultAddress& tracerResAddr : tracerResAddrs )
{ {
const std::vector<double>* tracerResult = const std::vector<double>* tracerResult =
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( tracerResAddr, timeStep ) ); &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->cellScalarResults( tracerResAddr, timeStep ) );
for ( size_t i = 0; i < summedTracerValues.size(); i++ ) for ( size_t i = 0; i < summedTracerValues.size(); i++ )
{ {
@ -202,8 +205,9 @@ void RigNumberOfFloodedPoreVolumesCalculator::calculate( RigMainGrid*
std::vector<std::vector<double>> summedTracersAtAllTimesteps ) std::vector<std::vector<double>> summedTracersAtAllTimesteps )
{ {
// size_t totalNumberOfCells = mainGrid->globalCellArray().size(); // size_t totalNumberOfCells = mainGrid->globalCellArray().size();
RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* actCellInfo =
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
caf::ProgressInfo progress( 2 * daysSinceSimulationStart.size(), "" ); caf::ProgressInfo progress( 2 * daysSinceSimulationStart.size(), "" );
@ -296,7 +300,8 @@ void RigNumberOfFloodedPoreVolumesCalculator::distributeNNCflow( const std::vect
const std::vector<double>* flowrateNNC, const std::vector<double>* flowrateNNC,
std::vector<double>& flowrateIntoCell ) std::vector<double>& flowrateIntoCell )
{ {
RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
// Find max count for connections with result. Allen results introduce connections without results // Find max count for connections with result. Allen results introduce connections without results
size_t connectionsWithResultCount = std::min( flowrateNNC->size(), connections.size() ); size_t connectionsWithResultCount = std::min( flowrateNNC->size(), connections.size() );
@ -336,7 +341,8 @@ void RigNumberOfFloodedPoreVolumesCalculator::distributeNeighbourCellFlow( RigMa
const std::vector<double>* flrWatResultK, const std::vector<double>* flrWatResultK,
std::vector<double>& totalFlowrateIntoCell ) std::vector<double>& totalFlowrateIntoCell )
{ {
RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
for ( size_t globalCellIndex = 0; globalCellIndex < mainGrid->globalCellArray().size(); globalCellIndex++ ) for ( size_t globalCellIndex = 0; globalCellIndex < mainGrid->globalCellArray().size(); globalCellIndex++ )
{ {

2
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -261,7 +261,7 @@ void RigReservoirBuilderMock::populateReservoir( RigEclipseCaseData* eclipseCase
addFaults( eclipseCase ); addFaults( eclipseCase );
// Set all cells active // Set all cells active
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ); RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
activeCellInfo->setReservoirCellCount( eclipseCase->mainGrid()->globalCellArray().size() ); activeCellInfo->setReservoirCellCount( eclipseCase->mainGrid()->globalCellArray().size() );
for ( size_t i = 0; i < eclipseCase->mainGrid()->globalCellArray().size(); i++ ) for ( size_t i = 0; i < eclipseCase->mainGrid()->globalCellArray().size(); i++ )
{ {

24
ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
View File

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

8
ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
View File

@ -60,8 +60,10 @@ RigTofWellDistributionCalculator::RigTofWellDistributionCalculator( RimEclipseRe
RigFlowDiagResults* flowDiagResults = flowDiagSolution->flowDiagResults(); RigFlowDiagResults* flowDiagResults = flowDiagSolution->flowDiagResults();
CVF_ASSERT( flowDiagResults ); CVF_ASSERT( flowDiagResults );
const std::vector<double>* porvResults = const std::vector<double>* porvResults = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::STATIC_NATIVE, "PORV", 0 ); RiaDefines::ResultCatType::STATIC_NATIVE,
"PORV",
0 );
if ( !porvResults ) if ( !porvResults )
{ {
return; return;
@ -74,7 +76,7 @@ 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 = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, const std::vector<double>* phaseResults = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::ResultCatType::DYNAMIC_NATIVE,
phaseResultName, phaseResultName,
timeStepIndex ); timeStepIndex );

19
ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
View File

@ -101,14 +101,14 @@ public:
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs( server, args ); RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs( server, args );
if ( !rimCase ) return true; if ( !rimCase ) return true;
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( args.size() > 2 ) if ( args.size() > 2 )
{ {
QString prorosityModelString = args[2]; QString prorosityModelString = args[2];
if ( prorosityModelString.toUpper() == "FRACTURE" ) if ( prorosityModelString.toUpper() == "FRACTURE" )
{ {
porosityModel = RiaDefines::FRACTURE_MODEL; porosityModel = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
} }
@ -428,7 +428,9 @@ public:
RigEclipseResultAddress addrToMaxTimeStepCountResult; RigEclipseResultAddress addrToMaxTimeStepCountResult;
if ( rimCase && rimCase->eclipseCaseData() ) if ( rimCase && rimCase->eclipseCaseData() )
{ {
rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount( &addrToMaxTimeStepCountResult ); rimCase->eclipseCaseData()
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->maxTimeStepCount( &addrToMaxTimeStepCountResult );
if ( !addrToMaxTimeStepCountResult.isValid() ) if ( !addrToMaxTimeStepCountResult.isValid() )
{ {
canFetchData = false; canFetchData = false;
@ -449,7 +451,7 @@ public:
std::vector<QDateTime> timeStepDates = std::vector<QDateTime> timeStepDates =
rimCase->eclipseCaseData() rimCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL ) ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->timeStepDates( RigEclipseResultAddress( addrToMaxTimeStepCountResult ) ); ->timeStepDates( RigEclipseResultAddress( addrToMaxTimeStepCountResult ) );
quint64 timeStepCount = timeStepDates.size(); quint64 timeStepCount = timeStepDates.size();
@ -516,7 +518,9 @@ public:
RigEclipseResultAddress addrToMaxTimeStepCountResult; RigEclipseResultAddress addrToMaxTimeStepCountResult;
if ( rimCase && rimCase->eclipseCaseData() ) if ( rimCase && rimCase->eclipseCaseData() )
{ {
rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount( &addrToMaxTimeStepCountResult ); rimCase->eclipseCaseData()
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->maxTimeStepCount( &addrToMaxTimeStepCountResult );
if ( !addrToMaxTimeStepCountResult.isValid() ) if ( !addrToMaxTimeStepCountResult.isValid() )
{ {
canFetchData = false; canFetchData = false;
@ -535,8 +539,9 @@ public:
return true; return true;
} }
std::vector<double> daysSinceSimulationStart = std::vector<double> daysSinceSimulationStart = rimCase->eclipseCaseData()
rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->daysSinceSimulationStart( addrToMaxTimeStepCountResult ); ->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->daysSinceSimulationStart( addrToMaxTimeStepCountResult );
quint64 timeStepCount = daysSinceSimulationStart.size(); quint64 timeStepCount = daysSinceSimulationStart.size();
quint64 byteCount = sizeof( quint64 ) + timeStepCount * sizeof( qint32 ); quint64 byteCount = sizeof( quint64 ) + timeStepCount * sizeof( qint32 );

8
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

@ -165,10 +165,10 @@ public:
QString porosityModelName; QString porosityModelName;
porosityModelName = args[2]; porosityModelName = args[2];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName.toUpper() == "FRACTURE" ) if ( porosityModelName.toUpper() == "FRACTURE" )
{ {
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
if ( !rimCase || !rimCase->eclipseCaseData() ) if ( !rimCase || !rimCase->eclipseCaseData() )
@ -338,10 +338,10 @@ public:
QString porosityModelName; QString porosityModelName;
porosityModelName = args[2]; porosityModelName = args[2];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName.toUpper() == "FRACTURE" ) if ( porosityModelName.toUpper() == "FRACTURE" )
{ {
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
if ( !rimCase || !rimCase->eclipseCaseData() ) if ( !rimCase || !rimCase->eclipseCaseData() )

2
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -316,7 +316,7 @@ public:
, m_bytesPerTimeStepToRead( 0 ) , m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 ) , m_currentTimeStepNumberToRead( 0 )
, m_invalidConnectionCountDetected( false ) , m_invalidConnectionCountDetected( false )
, m_porosityModelEnum( RiaDefines::MATRIX_MODEL ) , m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
} }

24
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -63,10 +63,10 @@ public:
QString propertyName = args[2]; QString propertyName = args[2];
QString porosityModelName = args[3]; QString porosityModelName = args[3];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" ) if ( porosityModelName == "Fracture" )
{ {
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
// Find the requested data // Find the requested data
@ -242,10 +242,10 @@ public:
return true; return true;
} }
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" ) if ( porosityModelName == "Fracture" )
{ {
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
bool isResultsLoaded = false; bool isResultsLoaded = false;
@ -403,7 +403,7 @@ public:
, m_bytesPerTimeStepToRead( 0 ) , m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 ) , m_currentTimeStepNumberToRead( 0 )
, m_invalidActiveCellCountDetected( false ) , m_invalidActiveCellCountDetected( false )
, m_porosityModelEnum( RiaDefines::MATRIX_MODEL ) , m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
} }
@ -418,7 +418,7 @@ public:
if ( porosityModelName == "Fracture" ) if ( porosityModelName == "Fracture" )
{ {
m_porosityModelEnum = RiaDefines::FRACTURE_MODEL; m_porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
// Find the requested data, Or create a set if we are setting data and it is not found // Find the requested data, Or create a set if we are setting data and it is not found
@ -770,7 +770,7 @@ public:
, m_bytesPerTimeStepToRead( 0 ) , m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 ) , m_currentTimeStepNumberToRead( 0 )
, m_invalidDataDetected( false ) , m_invalidDataDetected( false )
, m_porosityModelEnum( RiaDefines::MATRIX_MODEL ) , m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
{ {
} }
@ -794,7 +794,7 @@ public:
if ( porosityModelName == "Fracture" ) if ( porosityModelName == "Fracture" )
{ {
m_porosityModelEnum = RiaDefines::FRACTURE_MODEL; m_porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
RigGridBase* grid = rimCase->eclipseCaseData()->grid( m_currentGridIndex ); RigGridBase* grid = rimCase->eclipseCaseData()->grid( m_currentGridIndex );
@ -1165,11 +1165,11 @@ public:
} }
QString porosityModelName = args[2]; QString porosityModelName = args[2];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" ) if ( porosityModelName == "Fracture" )
{ {
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
std::vector<QString> propNames; std::vector<QString> propNames;
@ -1246,14 +1246,14 @@ public:
QString propertyName = args[2]; QString propertyName = args[2];
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL; RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( args.size() > 1 ) if ( args.size() > 1 )
{ {
QString prorosityModelString = args[3]; QString prorosityModelString = args[3];
if ( prorosityModelString.toUpper() == "FRACTURE" ) if ( prorosityModelString.toUpper() == "FRACTURE" )
{ {
porosityModel = RiaDefines::FRACTURE_MODEL; porosityModel = RiaDefines::PorosityModelType::FRACTURE_MODEL;
} }
} }

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

@ -58,7 +58,7 @@ TEST( RigReservoirTest, BasicTest10k )
cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData( resultCase.get() ); cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData( resultCase.get() );
{ {
RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL ); RigCaseCellResultsData* cellData = reservoir->results( PorosityModelType::MATRIX_MODEL );
QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE ); QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE );
EXPECT_EQ( 0, staticResults.size() ); EXPECT_EQ( 0, staticResults.size() );
@ -81,7 +81,7 @@ TEST( RigReservoirTest, BasicTest10k )
} }
{ {
RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL ); RigCaseCellResultsData* cellData = reservoir->results( PorosityModelType::MATRIX_MODEL );
QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE ); QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE );
EXPECT_EQ( 44, staticResults.size() ); EXPECT_EQ( 44, staticResults.size() );

11
ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
View File

@ -165,7 +165,8 @@ bool RiuPvtPlotUpdater::queryDataAndUpdatePlot( const RimEclipseResultDefinition
activeCellIndex ); activeCellIndex );
// 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::PorosityModelType::MATRIX_MODEL );
cellResultsData->ensureKnownResultLoaded( cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "RS" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "RS" ) );
cellResultsData->ensureKnownResultLoaded( cellResultsData->ensureKnownResultLoaded(
@ -178,28 +179,28 @@ bool RiuPvtPlotUpdater::queryDataAndUpdatePlot( const RimEclipseResultDefinition
cvf::ref<RigResultAccessor> rsAccessor = cvf::ref<RigResultAccessor> rsAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PVTNUM" ) ); "PVTNUM" ) );

12
ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
View File

@ -160,7 +160,8 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
eclipseResultCase->flowDiagSolverInterface()->calculateRelPermCurves( activeCellIndex ); eclipseResultCase->flowDiagSolverInterface()->calculateRelPermCurves( activeCellIndex );
// 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::PorosityModelType::MATRIX_MODEL );
cellResultsData->ensureKnownResultLoaded( cellResultsData->ensureKnownResultLoaded(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) ); RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
cellResultsData->ensureKnownResultLoaded( cellResultsData->ensureKnownResultLoaded(
@ -172,21 +173,21 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
cvf::ref<RigResultAccessor> swatAccessor = cvf::ref<RigResultAccessor> swatAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData, RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex, gridIndex,
RiaDefines::MATRIX_MODEL, RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::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::PorosityModelType::MATRIX_MODEL,
timeStepIndex, timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"SATNUM" ) ); "SATNUM" ) );
@ -312,7 +313,8 @@ size_t CellLookupHelper::mapToActiveCellIndex( const RigEclipseCaseData* eclipse
{ {
// Note!! // Note!!
// Which type of porosity model to choose? Currently hard-code to MATRIX_MODEL // Which type of porosity model to choose? Currently hard-code to MATRIX_MODEL
const RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::MATRIX_MODEL ); const RigActiveCellInfo* activeCellInfo =
eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
CVF_ASSERT( activeCellInfo ); CVF_ASSERT( activeCellInfo );