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() )
{
eclipseCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL )
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->clearScalarResult( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName() );
// 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() );
if ( eclipseCase )
{
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( caseData )
{
std::vector<RigEclipseResultAddress> resultsToDelete = selectedEclipseResults();
@ -240,7 +240,7 @@ QList<caf::PdmOptionItemInfo> RiaMemoryCleanup::calculateValueOptions( const caf
if ( eclipseCase )
{
std::set<RigEclipseResultAddress> resultsInUse = findEclipseResultsInUse();
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* caseData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( caseData )
{
m_eclipseResultAddresses = caseData->existingResults();

6
ApplicationCode/Application/RiaPorosityModel.cpp
View File

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

2
ApplicationCode/Application/RiaPorosityModel.h
View File

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

2
ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
View File

@ -86,7 +86,7 @@ caf::PdmScriptResponse RicfExportProperty::execute()
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 ) ) )
{

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

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

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

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

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

@ -926,8 +926,9 @@ RicMswExportInfo
const RimWellPath* wellPath,
const std::vector<RimWellPathFracture*>& fractures )
{
const RigMainGrid* grid = caseToApply->eclipseCaseData()->mainGrid();
const RigActiveCellInfo* activeCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
const RigMainGrid* grid = caseToApply->eclipseCaseData()->mainGrid();
const RigActiveCellInfo* activeCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RiaEclipseUnitTools::UnitSystem unitSystem = caseToApply->eclipseCaseData()->unitsType();
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
@ -1087,10 +1088,11 @@ std::vector<SubSegmentIntersectionInfo>
const RimWellPath* wellPath,
double& initialMD )
{
const RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints();
const std::vector<double>& mds = wellPathGeometry->measureDepths();
const RigActiveCellInfo* activeCellInfo =
eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
const std::vector<cvf::Vec3d>& coords = wellPathGeometry->wellPathPoints();
const std::vector<double>& mds = wellPathGeometry->measureDepths();
CVF_ASSERT( !coords.empty() && !mds.empty() );
std::vector<WellPathCellIntersectionInfo> intersections =
@ -1718,7 +1720,8 @@ std::vector<RigCompletionData>
RimEclipseCase* eclipseCase )
{
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() &&
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() );
if ( rimEclipeCase && rimEclipeCase->eclipseCaseData() )
{
return rimEclipeCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
return rimEclipeCase->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
}
return nullptr;

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

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

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

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

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

@ -76,7 +76,8 @@ void RicSaveEclipseInputVisibleCellsFeature::executeCommand( RimEclipseView*
std::vector<double> values;
cvf::UByteArray visibleCells;
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() );
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;
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( cvf::Vec3st(), cvf::Vec3st() );

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

@ -75,9 +75,9 @@ std::vector<RimSaturationPressurePlot*>
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(
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,
QStringList* wellsIntersectingOtherLgrs )
{
auto eclipseCaseData = eclipseCase->eclipseCaseData();
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::FRACTURE_MODEL );
auto eclipseCaseData = eclipseCase->eclipseCaseData();
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo =
eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
auto lgrs = RicExportLgrFeature::buildLgrsForWellPaths( wellPaths,
eclipseCase,
@ -302,13 +303,14 @@ void RicCreateTemporaryLgrFeature::deleteAllCachedData( RimEclipseCase* eclipseC
{
if ( eclipseCase )
{
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( cellResultsDataMatrix )
{
cellResultsDataMatrix->freeAllocatedResultsData();
}
RigCaseCellResultsData* cellResultsDataFracture = eclipseCase->results( RiaDefines::FRACTURE_MODEL );
RigCaseCellResultsData* cellResultsDataFracture =
eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
if ( cellResultsDataFracture )
{
cellResultsDataFracture->freeAllocatedResultsData();
@ -330,8 +332,9 @@ void RicCreateTemporaryLgrFeature::computeCachedData( RimEclipseCase* eclipseCas
{
if ( eclipseCase )
{
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* cellResultsDataFracture = eclipseCase->results( RiaDefines::FRACTURE_MODEL );
RigCaseCellResultsData* cellResultsDataMatrix = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigCaseCellResultsData* cellResultsDataFracture =
eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
if ( eclipseCaseData )

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

@ -469,9 +469,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
{
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) &&
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL )
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{
RiaLogging::warning( "Could not find a restart result property with name: \"" +
@ -525,9 +525,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
std::vector<RimGridTimeHistoryCurve*> createdCurves;
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) &&
if ( !( eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclCase->eclipseCaseData()
->results( RiaDefines::MATRIX_MODEL )
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{
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;
}
const RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL );
const RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
CVF_ASSERT( activeCellInfo );
@ -446,7 +446,7 @@ bool RifEclipseInputFileTools::exportKeywords( const QString& resul
{
return false;
}
RigCaseCellResultsData* cellResultsData = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* cellResultsData = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* activeCells = cellResultsData->activeCellInfo();
RigMainGrid* mainGrid = eclipseCase->mainGrid();
@ -802,7 +802,7 @@ std::map<QString, QString> RifEclipseInputFileTools::readProperties( const QStri
if ( eclipseKeywordData )
{
QString newResultName =
caseData->results( RiaDefines::MATRIX_MODEL )->makeResultNameUnique( fileKeywords[i].keyword );
caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->makeResultNameUnique( fileKeywords[i].keyword );
QString errMsg;
if ( readDataFromKeyword( eclipseKeywordData, caseData, newResultName, &errMsg ) )
{
@ -896,10 +896,12 @@ bool RifEclipseInputFileTools::readDataFromKeyword( ecl_kw_type* eclipseK
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;
scalarValueCount = caseData->activeCellInfo( RiaDefines::MATRIX_MODEL )->reservoirActiveCellCount();
scalarValueCount =
caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->reservoirActiveCellCount();
}
if ( !mathingItemCount )
@ -911,9 +913,10 @@ bool RifEclipseInputFileTools::readDataFromKeyword( ecl_kw_type* eclipseK
}
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->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 )
{
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 ) )
{
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;
}
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL );
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo =
eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
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
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" );
transferDynamicNNCData( mainEclGrid, eclipseCase->mainGrid() );
@ -493,7 +494,7 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
{
CVF_ASSERT( m_eclipseCase );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
CVF_ASSERT( matrixModelResults );
if ( fileName.isEmpty() )
@ -877,8 +878,9 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
return false;
}
RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL );
RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo =
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
activeCellInfo->setReservoirCellCount( reservoirCellCount );
fractureActiveCellInfo->setReservoirCellCount( reservoirCellCount );
@ -935,8 +937,8 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
progInfo.setNextProgressIncrement( m_filesWithSameBaseName.size() );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results( RiaDefines::FRACTURE_MODEL );
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
std::vector<RigEclipseTimeStepInfo> timeStepInfos;
@ -958,9 +960,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::PorosityModelType::MATRIX_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < matrixResultNames.size(); ++i )
@ -975,9 +977,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::PorosityModelType::FRACTURE_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < fractureResultNames.size(); ++i )
@ -1049,9 +1051,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::PorosityModelType::MATRIX_MODEL,
1 );
// Add ACTNUM
@ -1069,9 +1071,9 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
RiaDefines::PorosityModelType::FRACTURE_MODEL,
1 );
// Add ACTNUM
fractureResultNames += "ACTNUM";
@ -1153,7 +1155,7 @@ void RifReaderEclipseOutput::sourSimRlResult( const QString& result, size_t step
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 );
}
@ -2161,7 +2163,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
return QStringList();
}
if ( porosityModel == RiaDefines::FRACTURE_MODEL )
if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL )
{
if ( fractureActiveCellInfo->reservoirActiveCellCount() == 0 )
{
@ -2199,7 +2201,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
fractureActiveCellInfo->reservoirActiveCellCount();
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(),
sumFractureMatrixActiveCellCount ) )
@ -2207,7 +2209,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
validKeyword = true;
}
}
else if ( porosityModel == RiaDefines::FRACTURE_MODEL &&
else if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 )
{
if ( keywordDataItemCount <= timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(),
@ -2363,9 +2365,9 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
{
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(),
sourceResultValues.begin(),
@ -2373,7 +2375,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
}
else
{
RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL );
RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t sourceStartPosition = 0;
@ -2387,7 +2389,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
actCellInfo->gridActiveCellCounts( i, matrixActiveCellCount );
fracActCellInfo->gridActiveCellCounts( i, fractureActiveCellCount );
if ( matrixOrFracture == RiaDefines::MATRIX_MODEL )
if ( matrixOrFracture == RiaDefines::PorosityModelType::MATRIX_MODEL )
{
destinationResultValues->insert( destinationResultValues->end(),
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;
RigCaseCellResultsData* cellResults = eclipseCase->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* cellResults = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
std::vector<RigEclipseTimeStepInfo> timeStepInfos;
{

6
ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
View File

@ -438,7 +438,9 @@ grpc::Status RiaGrpcCaseService::GetDaysSinceStart( grpc::ServerContext* con
RigEclipseResultAddress addrToMaxTimeStepCountResult;
if ( eclipseCase && eclipseCase->eclipseCaseData() )
{
eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount( &addrToMaxTimeStepCountResult );
eclipseCase->eclipseCaseData()
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->maxTimeStepCount( &addrToMaxTimeStepCountResult );
if ( !addrToMaxTimeStepCountResult.isValid() )
{
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()
->results( RiaDefines::MATRIX_MODEL )
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->daysSinceSimulationStart( addrToMaxTimeStepCountResult );
for ( auto days : daysSinceSimulationStart )

2
ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
View File

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

4
ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
View File

@ -126,8 +126,8 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
resultAddresses.push_back( addresses[2] );
}
RigCaseCellResultsData* resultsData = eclipseCaseData->results( RiaDefines::MATRIX_MODEL );
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* resultsData = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
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 )
{
cvf::UByteArray visibleCells;
m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
m_case()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( m_cellFilterView )
{
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 );
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() );
timeStepCount = eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount();
timeStepCount =
eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
}
m_flowDiagResults = new RigFlowDiagResults( this, timeStepCount );
@ -167,11 +168,11 @@ std::map<std::string, std::vector<int>> RimFlowDiagSolution::allTracerActiveCell
if ( eclCase && eclCase->eclipseCaseData() )
{
const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid();
RigActiveCellInfo* activeCellInfo =
eclCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL ); // Todo: Must come from the results
// definition
const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid();
RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(
RiaDefines::PorosityModelType::MATRIX_MODEL ); // Todo: Must come from the results
// definition
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::UNDEFINED_PRODUCTION_TYPE );
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,
pipeBranchesCellIds,
tracerFractionCellValues,

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

@ -115,7 +115,7 @@ std::pair<RigEclipseResultAddress, QString>
{
for ( const auto& pressureDataName : PRESSURE_DATA_NAMES )
{
if ( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )
if ( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->hasResultEntry(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, pressureDataName ) ) )
{
@ -233,7 +233,7 @@ bool RimWellPlotTools::hasFlowData( RimEclipseResultCase* gridCase )
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 ) ) )
{
return true;
@ -502,7 +502,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::timeStep
if ( resultDataInfo.first.isValid() )
{
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 )
{
@ -556,8 +556,9 @@ std::set<QDateTime> RimWellPlotTools::availableSimWellTimesteps( RimEclipseCase*
{
std::set<QDateTime> availebleTimeSteps;
std::vector<QDateTime> allTimeSteps = eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->timeStepDates();
const RigSimWellData* simWell = eclCase->eclipseCaseData()->findSimWellData( simWellName );
std::vector<QDateTime> allTimeSteps =
eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
const RigSimWellData* simWell = eclCase->eclipseCaseData()->findSimWellData( simWellName );
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
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();
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
std::vector<QDateTime> timeSteps =
gridCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->timeStepDates();
gridCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->timeStepDates();
int currentTimeStepIndex = -1;
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();
if ( eclipseCaseData )
{
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results( porosityModel );
if ( cellResultsData )

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

@ -63,7 +63,7 @@ std::vector<RimSaturationPressurePlot*>
RigEclipseCaseData* eclipseCaseData = eclipseResultCase->eclipseCaseData();
if ( !eclipseCaseData ) return generatedPlots;
auto results = eclipseCaseData->results( RiaDefines::MATRIX_MODEL );
auto results = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
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
// now, use hardcoded value for MATRIX
plot->assignCaseAndEquilibriumRegion( RiaDefines::MATRIX_MODEL,
plot->assignCaseAndEquilibriumRegion( RiaDefines::PorosityModelType::MATRIX_MODEL,
eclipseResultCase,
zeroBasedEquilibriumRegion,
timeStep );

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

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

26
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -608,7 +608,8 @@ void RimEclipseCase::computeCachedData()
{
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;
if ( this->eclipseCaseData() )
{
m_fractureModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL ) );
m_matrixModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) );
m_fractureModelResults()->setCellResults(
eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
m_matrixModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
}
else
{
@ -730,9 +732,9 @@ cvf::BoundingBox RimEclipseCase::reservoirBoundingBox()
//--------------------------------------------------------------------------------------------------
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
{
@ -801,7 +803,7 @@ const RigCaseCellResultsData* RimEclipseCase::results( RiaDefines::PorosityModel
//--------------------------------------------------------------------------------------------------
RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel )
{
if ( porosityModel == RiaDefines::MATRIX_MODEL )
if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{
return m_matrixModelResults();
}
@ -814,7 +816,7 @@ RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::Poro
//--------------------------------------------------------------------------------------------------
const RimReservoirCellResultsStorage* RimEclipseCase::resultsStorage( RiaDefines::PorosityModelType porosityModel ) const
{
if ( porosityModel == RiaDefines::MATRIX_MODEL )
if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL )
{
return m_matrixModelResults();
}
@ -885,7 +887,7 @@ bool RimEclipseCase::openReserviorCase()
if ( createPlaceholderEntries )
{
{
RigCaseCellResultsData* results = this->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* results = this->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( results )
{
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 )
{
results->createPlaceholderResultEntries();
@ -989,7 +991,7 @@ QStringList RimEclipseCase::timeStepStrings() const
{
QStringList stringList;
const RigCaseCellResultsData* cellResultData = results( RiaDefines::MATRIX_MODEL );
const RigCaseCellResultsData* cellResultData = results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( cellResultData )
{
int timeStepCount = static_cast<int>( cellResultData->maxTimeStepCount() );
@ -1055,9 +1057,9 @@ std::set<QString> RimEclipseCase::sortedSimWellNames() 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>();
}

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
rigEclipseCase->mainGrid()->computeCachedData();
rigEclipseCase->mainGrid()->calculateFaults( rigEclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ) );
rigEclipseCase->mainGrid()->calculateFaults(
rigEclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
equalGrid = rigEclipseCase->mainGrid();
}

7
ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

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

18
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@ -91,11 +91,11 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
if ( fileNames.contains( RiaDefines::mockModelBasicInputCase() ) )
{
cvf::ref<RifReaderInterface> readerInterface = this->createMockModel( fileNames[0] );
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL )->computeDerivedData();
eclipseCaseData()->activeCellInfo( RiaDefines::FRACTURE_MODEL )->computeDerivedData();
eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDerivedData();
eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDerivedData();
QFileInfo gridFileName( fileNames[0] );
QString caseName = gridFileName.completeBaseName();
@ -210,8 +210,8 @@ bool RimEclipseInputCase::openEclipseGridFile()
CVF_ASSERT( this->eclipseCaseData() );
CVF_ASSERT( readerInterface.notNull() );
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
this->eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
@ -222,11 +222,11 @@ bool RimEclipseInputCase::openEclipseGridFile()
RiaApplication* app = RiaApplication::instance();
if ( app->preferences()->autocomputeDepthRelatedProperties )
{
results( RiaDefines::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::FRACTURE_MODEL )->computeDepthRelatedResults();
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDepthRelatedResults();
}
results( RiaDefines::MATRIX_MODEL )->computeCellVolumes();
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeCellVolumes();
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 newName = newValue.toString();
RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* matrixResults =
rimCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( matrixResults )
{
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->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;
}
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
progInfo.incrementProgress();
@ -231,11 +231,11 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
RiaApplication* app = RiaApplication::instance();
if ( app->preferences()->autocomputeDepthRelatedProperties )
{
results( RiaDefines::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::FRACTURE_MODEL )->computeDepthRelatedResults();
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeDepthRelatedResults();
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->computeDepthRelatedResults();
}
results( RiaDefines::MATRIX_MODEL )->computeCellVolumes();
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->computeCellVolumes();
return true;
}
@ -288,7 +288,8 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
CVF_ASSERT( mainEclipseCase && 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;
if ( !readerEclipseOutput->openAndReadActiveCellData( gridFileName(), timeStepDates, eclipseCase.p() ) )
{
@ -300,8 +301,8 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
readerInterface = readerEclipseOutput;
}
results( RiaDefines::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
CVF_ASSERT( this->eclipseCaseData() );
CVF_ASSERT( readerInterface.notNull() );
@ -318,9 +319,9 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
//--------------------------------------------------------------------------------------------------
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() )
{
@ -612,8 +613,8 @@ void RimEclipseResultCase::defineUiOrdering( QString uiConfigName, caf::PdmUiOrd
group->add( &m_flipXAxis );
group->add( &m_flipYAxis );
if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::MATRIX_MODEL ) &&
eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount() > 0 )
if ( eclipseCaseData() && eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) &&
eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount() > 0 )
{
auto group1 = uiOrdering.addNewGroup( "Time Step Filter" );
group1->setCollapsedByDefault( true );

107
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -199,10 +199,10 @@ bool RimEclipseStatisticsCase::openEclipseGridFile()
eclipseCase->setMainGrid( mainGrid );
eclipseCase->setActiveCellInfo( RiaDefines::MATRIX_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::MATRIX_MODEL ) );
eclipseCase->setActiveCellInfo( RiaDefines::FRACTURE_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::FRACTURE_MODEL ) );
eclipseCase->setActiveCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
eclipseCase->setActiveCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL,
gridCaseGroup->unionOfActiveCells( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
this->setReservoirData( eclipseCase.p() );
@ -259,14 +259,14 @@ void RimEclipseStatisticsCase::computeStatistics()
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;
}
// 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
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;
@ -294,28 +294,28 @@ void RimEclipseStatisticsCase::computeStatistics()
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,
m_selectedDynamicProperties()[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,
m_selectedStaticProperties()[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,
m_selectedGeneratedProperties()[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,
m_selectedInputProperties()[pIdx] ) );
}
@ -323,7 +323,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureDynamicProperties().size(); ++pIdx )
{
resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
m_selectedFractureDynamicProperties()[pIdx] ) );
}
@ -331,7 +331,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureStaticProperties().size(); ++pIdx )
{
resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::STATIC_NATIVE,
m_selectedFractureStaticProperties()[pIdx] ) );
}
@ -339,7 +339,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureGeneratedProperties().size(); ++pIdx )
{
resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::GENERATED,
m_selectedFractureGeneratedProperties()[pIdx] ) );
}
@ -347,7 +347,7 @@ void RimEclipseStatisticsCase::computeStatistics()
for ( size_t pIdx = 0; pIdx < m_selectedFractureInputProperties().size(); ++pIdx )
{
resultSpecification.append(
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::FRACTURE_MODEL,
RimEclipseStatisticsCaseEvaluator::ResSpec( RiaDefines::PorosityModelType::FRACTURE_MODEL,
RiaDefines::ResultCatType::INPUT_PROPERTY,
m_selectedFractureInputProperties()[pIdx] ) );
}
@ -489,50 +489,50 @@ QList<caf::PdmOptionItemInfo>
if ( &m_selectedDynamicProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList );
}
else if ( &m_selectedStaticProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList );
}
else if ( &m_selectedGeneratedProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList );
}
else if ( &m_selectedInputProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList );
}
else if ( &m_selectedFractureDynamicProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
return toOptionList( varList );
}
else if ( &m_selectedFractureStaticProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
return toOptionList( varList );
}
else if ( &m_selectedFractureGeneratedProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::GENERATED );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::GENERATED );
return toOptionList( varList );
}
else if ( &m_selectedFractureInputProperties == fieldNeedingOptions )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::INPUT_PROPERTY );
return toOptionList( varList );
}
@ -725,29 +725,29 @@ void RimEclipseStatisticsCase::updateSelectionListVisibilities()
// !caseGroup()->mainCase()->reservoirData()->results(RiaDefines::FRACTURE_MODEL)->resultCount()
m_selectedDynamicProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedGeneratedProperties.uiCapability()->setUiHidden(
isLocked ||
!( m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::MATRIX_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::MATRIX_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
m_selectedFractureDynamicProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) );
m_selectedFractureStaticProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::STATIC_NATIVE ) );
m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden(
isLocked ||
!( m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::GENERATED ) );
m_selectedFractureInputProperties.uiCapability()->setUiHidden(
isLocked || !( m_porosityModel() == RiaDefines::FRACTURE_MODEL &&
isLocked || !( m_porosityModel() == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
m_resultType() == RiaDefines::ResultCatType::INPUT_PROPERTY ) );
}
@ -769,8 +769,9 @@ void RimEclipseStatisticsCase::updatePercentileUiVisibility()
//--------------------------------------------------------------------------------------------------
bool RimEclipseStatisticsCase::hasComputedStatistics() const
{
if ( eclipseCaseData() && ( eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->existingResults().size() ||
eclipseCaseData()->results( RiaDefines::FRACTURE_MODEL )->existingResults().size() ) )
if ( eclipseCaseData() &&
( eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->existingResults().size() ||
eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->existingResults().size() ) )
{
return true;
}
@ -808,14 +809,14 @@ void RimEclipseStatisticsCase::updateConnectedEditorsAndReservoirViews()
//--------------------------------------------------------------------------------------------------
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();
@ -853,32 +854,32 @@ void RimEclipseStatisticsCase::populateResultSelection()
if ( m_selectedDynamicProperties().size() == 0 )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
if ( varList.contains( "SOIL" ) ) m_selectedDynamicProperties.v().push_back( "SOIL" );
if ( varList.contains( "PRESSURE" ) ) m_selectedDynamicProperties.v().push_back( "PRESSURE" );
}
if ( m_selectedStaticProperties().size() == 0 )
{
QStringList varList =
caseData->results( RiaDefines::MATRIX_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
if ( varList.contains( "PERMX" ) ) m_selectedStaticProperties.v().push_back( "PERMX" );
if ( varList.contains( "PORO" ) ) m_selectedStaticProperties.v().push_back( "PORO" );
}
if ( m_selectedFractureDynamicProperties().size() == 0 )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
if ( varList.contains( "SOIL" ) ) m_selectedFractureDynamicProperties.v().push_back( "SOIL" );
if ( varList.contains( "PRESSURE" ) ) m_selectedFractureDynamicProperties.v().push_back( "PRESSURE" );
}
if ( m_selectedFractureStaticProperties().size() == 0 )
{
QStringList varList =
caseData->results( RiaDefines::FRACTURE_MODEL )->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
QStringList varList = caseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )
->resultNames( RiaDefines::ResultCatType::STATIC_NATIVE );
if ( varList.contains( "PERMX" ) ) m_selectedFractureStaticProperties.v().push_back( "PERMX" );
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 );
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 =
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 );
destinationCellResults->createResultEntry( resAddr, true );
@ -346,8 +346,8 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults( const QList<ResSpec>
if ( !eclipseCase->reservoirViews.size() )
{
eclipseCase->results( RiaDefines::MATRIX_MODEL )->freeAllocatedResultsData();
eclipseCase->results( RiaDefines::FRACTURE_MODEL )->freeAllocatedResultsData();
eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->freeAllocatedResultsData();
eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->freeAllocatedResultsData();
}
}

2
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@ -63,7 +63,7 @@ public:
{
ResSpec()
: 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 )

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 );
RigCaseCellResultsData* resultsData =
eclipseView->eclipseCase()->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL );
eclipseView->eclipseCase()->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
resultsData->ensureKnownResultLoaded( resVarAddr );

20
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

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

5
ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp
View File

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

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

@ -345,7 +345,7 @@ void RimSummaryPlotFilterTextCurveSetEditor::fieldChangedByUi( const caf::PdmFie
for ( RimEclipseCase* eclCase : gridCasesToPlotFrom )
{
RigCaseCellResultsData* gridCellResults =
eclCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL );
eclCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !( gridCellResults && gridCellResults->resultInfo( cellResAddr.eclipseResultAddress ) ) )
{
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();
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
cvf::ref<RigResultAccessor> dataAccessObjectDx = createResultAccessor( m_case, "DX" );
cvf::ref<RigResultAccessor> dataAccessObjectDy = createResultAccessor( m_case, "DY" );
@ -380,7 +380,7 @@ cvf::ref<RigResultAccessor>
RigEclipseToStimPlanCellTransmissibilityCalculator::createResultAccessor( const RimEclipseCase* eclipseCase,
const QString& uiResultName )
{
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
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

18
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

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

2
ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp
View File

@ -43,7 +43,7 @@ RigEclipseCrossPlotResult RigEclipseCrossPlotDataExtractor::extract( RigEclipseC
{
RigEclipseCrossPlotResult result;
RigCaseCellResultsData* resultData = caseData->results( RiaDefines::MATRIX_MODEL );
RigCaseCellResultsData* resultData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
if ( !resultData ) return result;
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;
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;
RigFlowDiagTimeStepResult result(
m_eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL )->reservoirActiveCellCount() );
RigFlowDiagTimeStepResult result( m_eclipseCase->eclipseCaseData()
->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )
->reservoirActiveCellCount() );
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 maxTimeStepCount =
m_eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount();
m_eclipseCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
if ( restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount )
{
@ -329,10 +330,12 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
CVF_ASSERT( currentRestartData );
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()
->results( RiaDefines::MATRIX_MODEL )
->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->reportStepNumber( addrToMaxTimeStepCountResult, timeStepIndex );
if ( !currentRestartData->selectReportStep( reportStepNumber ) )
@ -349,7 +352,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate( size_t
try
{
if ( m_eclipseCase->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->hasFlowDiagUsableFluxes() )
if ( m_eclipseCase->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->hasFlowDiagUsableFluxes() )
{
Opm::FlowDiagnostics::ConnectionValues connectionsVals =
RigFlowDiagInterfaceTools::extractFluxFieldFromRestartFile( *( m_opmFlowDiagStaticData->m_eclGraph ),
@ -528,7 +531,7 @@ bool RigFlowDiagSolverInterface::ensureStaticDataObjectInstanceCreated()
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 );
if ( eclOutput )
{
@ -562,19 +565,19 @@ void RigFlowDiagSolverInterface::assignPhaseCorrecedPORV( RigFlowDiagResultAddre
switch ( phaseSelection )
{
case RigFlowDiagResultAddress::PHASE_OIL:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL",
timeStepIdx );
break;
case RigFlowDiagResultAddress::PHASE_GAS:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS",
timeStepIdx );
break;
case RigFlowDiagResultAddress::PHASE_WAT:
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL,
phaseSaturation = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT",
timeStepIdx );

2
ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
View File

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

2
ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
View File

@ -109,7 +109,7 @@ void RigFlowDiagVisibleCellsStatCalc::mobileVolumeWeightedMean( size_t timeStepI
m_resultsData->flowDiagSolution()->firstAncestorOrThisOfType( eclCase );
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() );

40
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -42,13 +42,15 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid();
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 );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
size_t timeStepCount = caseToApply->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->maxTimeStepCount();
size_t totalProgress = tracerNames.size() + 8 + timeStepCount + 2 * timeStepCount;
size_t 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." );
progress.setProgressDescription( "Loading required results" );
// PORV
@ -110,7 +112,7 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
progress.incrementProgress();
std::vector<double> daysSinceSimulationStart =
caseToApply->eclipseCaseData()->results( RiaDefines::MATRIX_MODEL )->daysSinceSimulationStart();
caseToApply->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->daysSinceSimulationStart();
progress.incrementProgress();
@ -119,24 +121,24 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
const std::vector<double>* flowrateI = nullptr;
if ( hasFlowrateI )
{
flowrateI =
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatIAddr, timeStep ) );
flowrateI = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->cellScalarResults( flrWatIAddr, timeStep ) );
}
flowrateIatAllTimeSteps.push_back( flowrateI );
const std::vector<double>* flowrateJ = nullptr;
if ( hasFlowrateJ )
{
flowrateJ =
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatJAddr, timeStep ) );
flowrateJ = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->cellScalarResults( flrWatJAddr, timeStep ) );
}
flowrateJatAllTimeSteps.push_back( flowrateJ );
const std::vector<double>* flowrateK = nullptr;
if ( hasFlowrateK )
{
flowrateK =
&( eclipseCaseData->results( RiaDefines::MATRIX_MODEL )->cellScalarResults( flrWatKAddr, timeStep ) );
flowrateK = &( eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->cellScalarResults( flrWatKAddr, timeStep ) );
}
flowrateKatAllTimeSteps.push_back( flowrateK );
@ -150,7 +152,8 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
for ( const RigEclipseResultAddress& tracerResAddr : tracerResAddrs )
{
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++ )
{
@ -202,8 +205,9 @@ void RigNumberOfFloodedPoreVolumesCalculator::calculate( RigMainGrid*
std::vector<std::vector<double>> summedTracersAtAllTimesteps )
{
// size_t totalNumberOfCells = mainGrid->globalCellArray().size();
RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount();
caf::ProgressInfo progress( 2 * daysSinceSimulationStart.size(), "" );
@ -296,7 +300,8 @@ void RigNumberOfFloodedPoreVolumesCalculator::distributeNNCflow( const std::vect
const std::vector<double>* flowrateNNC,
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
size_t connectionsWithResultCount = std::min( flowrateNNC->size(), connections.size() );
@ -336,7 +341,8 @@ void RigNumberOfFloodedPoreVolumesCalculator::distributeNeighbourCellFlow( RigMa
const std::vector<double>* flrWatResultK,
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++ )
{

2
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -261,7 +261,7 @@ void RigReservoirBuilderMock::populateReservoir( RigEclipseCaseData* eclipseCase
addFaults( eclipseCase );
// 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() );
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();
if ( !eclipseCaseData ) return;
const std::vector<double>* swatResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT", timestep );
const std::vector<double>* soilResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL", timestep );
const std::vector<double>* sgasResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS", timestep );
const std::vector<double>* porvResults =
eclipseCaseData->resultValues( RiaDefines::MATRIX_MODEL, RiaDefines::ResultCatType::STATIC_NATIVE, "PORV", 0 );
const std::vector<double>* swatResults = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT",
timestep );
const std::vector<double>* soilResults = eclipseCaseData->resultValues( RiaDefines::PorosityModelType::MATRIX_MODEL,
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SOIL",
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();

8
ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
View File

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

19
ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
View File

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

8
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

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

2
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -316,7 +316,7 @@ public:
, m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 )
, 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 porosityModelName = args[3];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" )
{
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
}
// Find the requested data
@ -242,10 +242,10 @@ public:
return true;
}
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" )
{
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
}
bool isResultsLoaded = false;
@ -403,7 +403,7 @@ public:
, m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 )
, m_invalidActiveCellCountDetected( false )
, m_porosityModelEnum( RiaDefines::MATRIX_MODEL )
, m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
{
}
@ -418,7 +418,7 @@ public:
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
@ -770,7 +770,7 @@ public:
, m_bytesPerTimeStepToRead( 0 )
, m_currentTimeStepNumberToRead( 0 )
, m_invalidDataDetected( false )
, m_porosityModelEnum( RiaDefines::MATRIX_MODEL )
, m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
{
}
@ -794,7 +794,7 @@ public:
if ( porosityModelName == "Fracture" )
{
m_porosityModelEnum = RiaDefines::FRACTURE_MODEL;
m_porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
}
RigGridBase* grid = rimCase->eclipseCaseData()->grid( m_currentGridIndex );
@ -1165,11 +1165,11 @@ public:
}
QString porosityModelName = args[2];
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( porosityModelName == "Fracture" )
{
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::PorosityModelType::FRACTURE_MODEL;
}
std::vector<QString> propNames;
@ -1246,14 +1246,14 @@ public:
QString propertyName = args[2];
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
if ( args.size() > 1 )
{
QString prorosityModelString = args[3];
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() );
{
RigCaseCellResultsData* cellData = reservoir->results( MATRIX_MODEL );
RigCaseCellResultsData* cellData = reservoir->results( PorosityModelType::MATRIX_MODEL );
QStringList staticResults = cellData->resultNames( ResultCatType::STATIC_NATIVE );
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 );
EXPECT_EQ( 44, staticResults.size() );

11
ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
View File

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

12
ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
View File

@ -160,7 +160,8 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
eclipseResultCase->flowDiagSolverInterface()->calculateRelPermCurves( activeCellIndex );
// 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(
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
cellResultsData->ensureKnownResultLoaded(
@ -172,21 +173,21 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot( const RimEclips
cvf::ref<RigResultAccessor> swatAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex,
RiaDefines::MATRIX_MODEL,
RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SWAT" ) );
cvf::ref<RigResultAccessor> sgasAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex,
RiaDefines::MATRIX_MODEL,
RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
"SGAS" ) );
cvf::ref<RigResultAccessor> satnumAccessor =
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
gridIndex,
RiaDefines::MATRIX_MODEL,
RiaDefines::PorosityModelType::MATRIX_MODEL,
timeStepIndex,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"SATNUM" ) );
@ -312,7 +313,8 @@ size_t CellLookupHelper::mapToActiveCellIndex( const RigEclipseCaseData* eclipse
{
// Note!!
// 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 );