diff --git a/ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp b/ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp
index 11974e4e53..96a0c949e2 100644
--- a/ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp
+++ b/ApplicationCode/Application/RiaCompletionTypeCalculationScheduler.cpp
@@ -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
diff --git a/ApplicationCode/Application/RiaMemoryCleanup.cpp b/ApplicationCode/Application/RiaMemoryCleanup.cpp
index 33590187a0..3055943bee 100644
--- a/ApplicationCode/Application/RiaMemoryCleanup.cpp
+++ b/ApplicationCode/Application/RiaMemoryCleanup.cpp
@@ -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();
diff --git a/ApplicationCode/Application/RiaPorosityModel.cpp b/ApplicationCode/Application/RiaPorosityModel.cpp
index 80e6f1f7d7..5fe18f6153 100644
--- a/ApplicationCode/Application/RiaPorosityModel.cpp
+++ b/ApplicationCode/Application/RiaPorosityModel.cpp
@@ -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
diff --git a/ApplicationCode/Application/RiaPorosityModel.h b/ApplicationCode/Application/RiaPorosityModel.h
index 3a17067544..a2edf187ce 100644
--- a/ApplicationCode/Application/RiaPorosityModel.h
+++ b/ApplicationCode/Application/RiaPorosityModel.h
@@ -23,7 +23,7 @@
 //--------------------------------------------------------------------------------------------------
 namespace RiaDefines
 {
-enum PorosityModelType
+enum class PorosityModelType
 {
     MATRIX_MODEL,
     FRACTURE_MODEL
diff --git a/ApplicationCode/CommandFileInterface/RicfExportProperty.cpp b/ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
index 5280e93cde..2d387d2951 100644
--- a/ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
+++ b/ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
@@ -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 ) ) )
     {
diff --git a/ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp b/ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
index 80801823e5..cbaeaf85e0 100644
--- a/ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
+++ b/ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
@@ -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;
 
diff --git a/ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp b/ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
index 62b3f01b04..ecee3fc82b 100644
--- a/ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
+++ b/ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
@@ -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 )
     {
diff --git a/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp b/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
index f61800c9db..e1233db185 100644
--- a/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
+++ b/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
@@ -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 =
diff --git a/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp b/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
index 7f15902f68..acc3ccec7b 100644
--- a/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
+++ b/ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
@@ -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] ) )
diff --git a/ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp b/ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp
index 42971e2072..d1342672cf 100644
--- a/ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp
+++ b/ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp
@@ -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;
diff --git a/ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp b/ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp
index a201a23eeb..86bb0e14b8 100644
--- a/ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp
+++ b/ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp
@@ -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() )
diff --git a/ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp b/ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
index e8f905ba24..c7b53c9f7a 100644
--- a/ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
+++ b/ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
@@ -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() )
diff --git a/ApplicationCode/Commands/ExportCommands/RicSaveEclipseInputVisibleCellsFeature.cpp b/ApplicationCode/Commands/ExportCommands/RicSaveEclipseInputVisibleCellsFeature.cpp
index e6024961b9..fbdbd37acc 100644
--- a/ApplicationCode/Commands/ExportCommands/RicSaveEclipseInputVisibleCellsFeature.cpp
+++ b/ApplicationCode/Commands/ExportCommands/RicSaveEclipseInputVisibleCellsFeature.cpp
@@ -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 )
     {
diff --git a/ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesFeature.cpp b/ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesFeature.cpp
index 8f4f210084..2c7f64637e 100644
--- a/ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesFeature.cpp
+++ b/ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesFeature.cpp
@@ -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() );
diff --git a/ApplicationCode/Commands/GridCrossPlotCommands/RicCreateSaturationPressurePlotsFeature.cpp b/ApplicationCode/Commands/GridCrossPlotCommands/RicCreateSaturationPressurePlotsFeature.cpp
index 6ae2e78db4..0b0623c4cd 100644
--- a/ApplicationCode/Commands/GridCrossPlotCommands/RicCreateSaturationPressurePlotsFeature.cpp
+++ b/ApplicationCode/Commands/GridCrossPlotCommands/RicCreateSaturationPressurePlotsFeature.cpp
@@ -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" ) ) )
diff --git a/ApplicationCode/Commands/RicCreateTemporaryLgrFeature.cpp b/ApplicationCode/Commands/RicCreateTemporaryLgrFeature.cpp
index c91bd91cfe..091fefe211 100644
--- a/ApplicationCode/Commands/RicCreateTemporaryLgrFeature.cpp
+++ b/ApplicationCode/Commands/RicCreateTemporaryLgrFeature.cpp
@@ -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 )
diff --git a/ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp b/ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
index 87ab62d2c5..60bd89f0e5 100644
--- a/ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
+++ b/ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
@@ -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: \"" +
diff --git a/ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp b/ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
index 91bf1041e1..33b7151c7f 100644
--- a/ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
+++ b/ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
@@ -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 );
diff --git a/ApplicationCode/FileInterface/RifEclipseInputPropertyLoader.cpp b/ApplicationCode/FileInterface/RifEclipseInputPropertyLoader.cpp
index 2352a4d390..b7a09cc64f 100644
--- a/ApplicationCode/FileInterface/RifEclipseInputPropertyLoader.cpp
+++ b/ApplicationCode/FileInterface/RifEclipseInputPropertyLoader.cpp
@@ -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;
diff --git a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp b/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
index 8906cb99b6..424483b273 100644
--- a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
+++ b/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
@@ -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,
diff --git a/ApplicationCode/FileInterface/RifReaderMockModel.cpp b/ApplicationCode/FileInterface/RifReaderMockModel.cpp
index 54d045532f..2598adef9b 100644
--- a/ApplicationCode/FileInterface/RifReaderMockModel.cpp
+++ b/ApplicationCode/FileInterface/RifReaderMockModel.cpp
@@ -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;
     {
diff --git a/ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp b/ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
index a099cae4dd..c05b602a64 100644
--- a/ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
+++ b/ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
@@ -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 )
diff --git a/ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp b/ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
index dcda32f210..0a646c05a8 100644
--- a/ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
+++ b/ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
@@ -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 )
diff --git a/ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp b/ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
index 2a13817747..f26fb58124 100644
--- a/ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
+++ b/ApplicationCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
@@ -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();
 
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp b/ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
index 34564a7a45..4dccc8312b 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
@@ -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 )
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp b/ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
index f8aa678d58..548aabb1fb 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
@@ -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 )
         {
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp b/ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
index dbf15cf2f6..e161e0a664 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
@@ -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,
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp b/ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
index a70bc30899..aaad6f0ad3 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
@@ -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 )
     {
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp b/ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
index 2c0db5ae45..93398f5845 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
@@ -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 )
         {
diff --git a/ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp b/ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
index 0231142fa7..81b79c8377 100644
--- a/ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
+++ b/ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
@@ -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 )
                 {
diff --git a/ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp b/ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
index e852dca573..89b37c8e54 100644
--- a/ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
+++ b/ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
@@ -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 )
diff --git a/ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp b/ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
index a4f30337fd..333236e9b2 100644
--- a/ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
+++ b/ApplicationCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
@@ -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 );
diff --git a/ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp b/ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
index 6ec3e47755..9127122716 100644
--- a/ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
+++ b/ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
@@ -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;
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp b/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
index 026b089f82..509a84eabb 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
@@ -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>();
 }
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp b/ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
index dcf239a1c9..e44c383df2 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
@@ -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();
     }
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp b/ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
index 60f6f2af3c..99636782de 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
@@ -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 );
 }
 
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp b/ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
index 0b1997cfd8..a446d556f1 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
@@ -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;
 }
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp b/ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
index ad19a78a3f..fbb9719c56 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
@@ -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 ) )
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp b/ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
index 19d7a028fb..da36ed3dc0 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
@@ -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 );
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
index 583379a4b1..ea5451584c 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
@@ -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" );
     }
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
index a4b393edfb..3f1298f31f 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
+++ b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
@@ -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();
             }
         }
 
diff --git a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
index 320e1f99b0..9ab43b2b12 100644
--- a/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
+++ b/ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
@@ -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 )
diff --git a/ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp b/ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp
index 1a95ef8921..84c003a4a0 100644
--- a/ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp
+++ b/ApplicationCode/ProjectDataModel/RimElementVectorResult.cpp
@@ -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 );
 
diff --git a/ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp b/ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
index 63449c5874..335bda999d 100644
--- a/ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
+++ b/ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
@@ -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();
     }
diff --git a/ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp b/ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp
index 3b0d2601cf..b5d32c3a2c 100644
--- a/ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp
+++ b/ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp
@@ -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();
diff --git a/ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp b/ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
index 9295677500..8fbdaf6e4b 100644
--- a/ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
+++ b/ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
@@ -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: \"" +
diff --git a/ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp b/ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
index 306ad71188..16ab6425e3 100644
--- a/ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
+++ b/ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
@@ -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
diff --git a/ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp b/ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
index c2dcae36ed..a708c36c62 100644
--- a/ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
@@ -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();
     }
diff --git a/ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp b/ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp
index c0101e9c08..92ec771be5 100644
--- a/ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigEclipseCrossPlotDataExtractor.cpp
@@ -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;
diff --git a/ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp b/ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
index 58582082e3..e0e908deec 100644
--- a/ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
@@ -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
 }
 
 //--------------------------------------------------------------------------------------------------
diff --git a/ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp b/ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
index 5b61e21477..2c737b198e 100644
--- a/ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
@@ -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 );
diff --git a/ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp b/ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
index 1fd6b20571..b6680e90a7 100644
--- a/ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
@@ -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() );
 
diff --git a/ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp b/ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
index 511a081754..f1f401a6a8 100644
--- a/ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
@@ -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() );
 
diff --git a/ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp b/ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
index 5d951b0441..d5f38a828a 100644
--- a/ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
@@ -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++ )
     {
diff --git a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
index 3365e6fbb7..a15452052d 100644
--- a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
@@ -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++ )
     {
diff --git a/ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp b/ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
index d0dda3423d..4dc72c37b8 100644
--- a/ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
@@ -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();
 
diff --git a/ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp b/ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
index 6b0dbebd0e..f614d36771 100644
--- a/ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
+++ b/ApplicationCode/ReservoirDataModel/RigTofWellDistributionCalculator.cpp
@@ -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 );
diff --git a/ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp b/ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
index aa6716fc5e..fce0d39736 100644
--- a/ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
+++ b/ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
@@ -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 );
diff --git a/ApplicationCode/SocketInterface/RiaGeometryCommands.cpp b/ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
index 9605593cc4..87827e0f8d 100644
--- a/ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
+++ b/ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
@@ -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() )
diff --git a/ApplicationCode/SocketInterface/RiaNNCCommands.cpp b/ApplicationCode/SocketInterface/RiaNNCCommands.cpp
index 3effaab316..264ae65e92 100644
--- a/ApplicationCode/SocketInterface/RiaNNCCommands.cpp
+++ b/ApplicationCode/SocketInterface/RiaNNCCommands.cpp
@@ -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 )
     {
     }
 
diff --git a/ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp b/ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
index a57fee2d2c..a973d45aa2 100644
--- a/ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
+++ b/ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
@@ -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;
             }
         }
 
diff --git a/ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp b/ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
index 25eadb3254..10c0b6eace 100644
--- a/ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
+++ b/ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
@@ -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() );
diff --git a/ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp b/ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
index 5bf88c705a..f7ffdb2649 100644
--- a/ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
+++ b/ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
@@ -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" ) );
diff --git a/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp b/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
index fd7f7493b9..fcb5e5b492 100644
--- a/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
+++ b/ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
@@ -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 );