fmu-pem 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

fmu/pem/pem_functions/regression_models.py

@@ -4,9 +4,6 @@ Regression based on polynomial models for saturated sandstones. The models are
 based on porosity polynomials to estimate either Vp and Vs, or K and Mu.
 """
 
-from pathlib import Path
-from typing import List, Union
-
 import numpy as np
 import numpy.typing as npt
 from rock_physics_open.equinor_utilities.std_functions import (
@@ -16,24 +13,31 @@ from rock_physics_open.equinor_utilities.std_functions import (
     velocity,
     voigt_reuss_hill,
 )
-from rock_physics_open.t_matrix_models import carbonate_pressure_model
 
 from fmu.pem.pem_utilities import (
     DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
-    PemConfig,
+    EffectiveMineralProperties,
     PressureProperties,
+    RockMatrixProperties,
     SaturatedRockProperties,
     filter_and_one_dim,
     reverse_filter_and_restore,
 )
-from fmu.pem.pem_utilities.enum_defs import MineralMixModel
+from fmu.pem.pem_utilities.enum_defs import (
+    MineralMixModel,
+    ParameterTypes,
+    PhysicsPressureModelTypes,
+)
 from fmu.pem.pem_utilities.rpm_models import (
     KMuRegressionParams,
     VpVsRegressionParams,
 )
 
+from .pressure_sensitivity import (
+    apply_dry_rock_pressure_sensitivity_model,
+)
+
 
 def gen_regression(
     porosity: np.ndarray, polynom_weights: list | np.ndarray
@@ -48,14 +52,17 @@ def gen_regression(
         Vp [m/s]
     """
     pol = np.polynomial.Polynomial(polynom_weights)
-    return pol(porosity)
+    # Call to Polynomial class will return ndarray or float, depending on input.
+    # This is not recognised by the
+    poly_val: np.ndarray = pol(porosity)  # type: ignore
+    return poly_val
 
 
 def dry_rock_regression(
-    porosity: npt.NDArray[np.float64] | np.ma.MaskedArray,
-    rho_min: npt.NDArray[np.float64] | np.ma.MaskedArray,
+    porosity: npt.NDArray[np.float64],
+    rho_min: npt.NDArray[np.float64],
     params: VpVsRegressionParams | KMuRegressionParams,
-) -> DryRockProperties:
+) -> tuple[npt.NDArray[np.float64], ...]:
     """
     Calculates dry rock properties based on porosity and polynomial weights.
 
@@ -72,11 +79,11 @@ def dry_rock_regression(
         ValueError: If an invalid mode is provided or necessary weights for
         the selected mode are missing.
     """
-    if not params.rho_regression:
-        # rho_regression = False, use mineral density
+    if not params.rho_model:
+        # rho_model = False, use mineral density
         rho_dry = rho_min * (1 - porosity)
     else:
-        rho_dry = gen_regression(porosity, params.rho_weights)
+        rho_dry = gen_regression(porosity, params.rho_model.rho_weights)
 
     if (
         params.mode == "vp_vs"
@@ -96,47 +103,39 @@ def dry_rock_regression(
     else:
         raise ValueError("Invalid mode or missing weights for the selected mode.")
 
-    return DryRockProperties(
-        bulk_modulus=np.ma.MaskedArray(k_dry),
-        shear_modulus=np.ma.MaskedArray(mu),
-        dens=np.ma.MaskedArray(rho_dry),
-    )
+    return k_dry, mu, rho_dry
 
 
 def run_regression_models(
-    mineral: MatrixProperties,
+    matrix: EffectiveMineralProperties,
     fluid_properties: list[EffectiveFluidProperties],
     porosity: np.ma.MaskedArray,
     pressure: list[PressureProperties],
-    config: PemConfig,
-    vsh: Union[np.ma.MaskedArray, None] = None,
-    pres_model_vp: Path = Path("carbonate_pressure_model_vp_exp.pkl"),
-    pres_model_vs: Path = Path("carbonate_pressure_model_vs_exp.pkl"),
-) -> List[SaturatedRockProperties]:
+    rock_matrix: RockMatrixProperties,
+    vsh: np.ma.MaskedArray | None = None,
+) -> tuple[list[SaturatedRockProperties], list[DryRockProperties]]:
     """Run regression models for saturated rock properties.
 
     Args:
-        mineral: Mineral properties containing bulk modulus (k) [Pa],
+        matrix: Effective mineral properties containing bulk modulus (k) [Pa],
             shear modulus (mu) [Pa] and density (rho_sat) [kg/m3]
-        fluid_properties: List of fluid properties,
+        fluid_properties: list of fluid properties,
             each containing bulk modulus (k) [Pa] and density (rho_sat) [kg/m3]
         porosity: Porosity as a masked array [fraction]
-        pressure: List of pressure properties containing effective pressure values
-            [bar] following Eclipse reservoir simulator convention
-        config: Parameters for the PEM
+        pressure: list of pressure properties containing effective pressure values
+            in unit Pa
+        rock_matrix: rock matrix properties
         vsh: Volume of shale as a masked array [fraction], optional
-        pres_model_vp: Path to the pressure sensitivity model file for P-wave velocity
-            (default: "carbonate_pressure_model_vp_exp_2023.pkl")
-        pres_model_vs: Path to the pressure sensitivity model file for S-wave velocity
-            (default: "carbonate_pressure_model_vs_exp_2023.pkl")
-
 
     Returns:
-        List[SaturatedRockProperties]: Saturated rock properties for each time step.
+        list[SaturatedRockProperties]: Saturated rock properties for each time step.
             Only fluid properties change between time steps in this model.
+        list[DryRockProperties]: dry rock properties with bulk modulus [Pa], shear
+            modulus [Pa] and density [kg/m^3]
     """
 
     saturated_props = []
+    dry_props = []
     tmp_pres_over = None
     tmp_pres_form = None
     tmp_pres_depl = None
@@ -148,12 +147,14 @@ def run_regression_models(
         multiple_lithologies = False
     else:
         multiple_lithologies = True
-    # Convert pressure from bar to Pa
-    pres_ovb = pressure[0].overburden_pressure * 1.0e5
-    pres_form = pressure[0].formation_pressure * 1.0e5
+
+    # Initial pressure conditions
+    pres_ovb = pressure[0].overburden_pressure
+    pres_form = pressure[0].formation_pressure
     for time_step, fl_prop in enumerate(fluid_properties):
-        if time_step > 0 and config.rock_matrix.pressure_sensitivity:
-            pres_depl = pressure[time_step].formation_pressure * 1.0e5
+        # Prepare data using filter_and_one_dim
+        if time_step > 0 and rock_matrix.pressure_sensitivity:
+            pres_depl = pressure[time_step].formation_pressure
             (
                 mask,
                 tmp_min_k,
@@ -167,11 +168,11 @@ def run_regression_models(
                 tmp_pres_form,
                 tmp_pres_depl,
             ) = filter_and_one_dim(
-                mineral.bulk_modulus,
-                mineral.shear_modulus,
-                mineral.dens,
+                matrix.bulk_modulus,
+                matrix.shear_modulus,
+                matrix.density,
                 fl_prop.bulk_modulus,
-                fl_prop.dens,
+                fl_prop.density,
                 porosity,
                 vsh,
                 pres_ovb,
@@ -190,72 +191,103 @@ def run_regression_models(
                 tmp_por,
                 tmp_vsh,
             ) = filter_and_one_dim(
-                mineral.bulk_modulus,
-                mineral.shear_modulus,
-                mineral.dens,
+                matrix.bulk_modulus,
+                matrix.shear_modulus,
+                matrix.density,
                 fl_prop.bulk_modulus,
-                fl_prop.dens,
+                fl_prop.density,
                 porosity,
                 vsh,
+                return_numpy_array=True,
             )
+
         if not multiple_lithologies:
-            dry_props = dry_rock_regression(
-                tmp_por, tmp_min_rho, config.rock_matrix.rpm.parameters.sandstone
+            k_dry, mu, rho_dry = dry_rock_regression(
+                tmp_por, tmp_min_rho, rock_matrix.model.parameters.sandstone
             )
         else:
-            dry_props_sand = dry_rock_regression(
-                tmp_por, tmp_min_rho, config.rock_matrix.rpm.parameters.sandstone
-            )
-            dry_props_shale = dry_rock_regression(
-                tmp_por, tmp_min_rho, config.rock_matrix.rpm.parameters.shale
+            k_sand, mu_sand, rho_sand = dry_rock_regression(
+                tmp_por, tmp_min_rho, rock_matrix.model.parameters.sandstone
             )
-            dry_rho = (
-                dry_props_sand.dens * (1.0 - tmp_vsh) + dry_props_shale.dens * tmp_vsh
+            k_shale, mu_shale, rho_shale = dry_rock_regression(
+                tmp_por, tmp_min_rho, rock_matrix.model.parameters.shale
             )
-            if config.rock_matrix.mineral_mix_model == MineralMixModel.HASHIN_SHTRIKMAN:
+            rho_dry = rho_sand * (1.0 - tmp_vsh) + rho_shale * tmp_vsh
+            if rock_matrix.mineral_mix_model == MineralMixModel.HASHIN_SHTRIKMAN:
                 k_dry, mu = hashin_shtrikman_average(
-                    dry_props_sand.bulk_modulus,
-                    dry_props_shale.bulk_modulus,
-                    dry_props_sand.shear_modulus,
-                    dry_props_shale.shear_modulus,
-                    (1.0 - tmp_vsh),
+                    k1=k_sand, mu1=mu_sand, k2=k_shale, mu2=mu_shale, f=(1.0 - tmp_vsh)
                 )
             else:
                 k_dry, mu = voigt_reuss_hill(
-                    dry_props_sand.bulk_modulus,
-                    dry_props_shale.bulk_modulus,
-                    dry_props_sand.shear_modulus,
-                    dry_props_shale.shear_modulus,
-                    (1.0 - tmp_vsh),
+                    k1=k_sand, mu1=mu_sand, k2=k_shale, mu2=mu_shale, f1=(1.0 - tmp_vsh)
                 )
-            dry_props = DryRockProperties(
-                bulk_modulus=k_dry, shear_modulus=mu, dens=dry_rho
-            )
 
-        k_sat = gassmann(dry_props.bulk_modulus, tmp_por, tmp_fl_prop_k, tmp_min_k)
-        rho_sat = dry_props.dens + tmp_por * tmp_fl_prop_rho
-        vp, vs = velocity(k_sat, dry_props.shear_modulus, rho_sat)[0:2]
-        if time_step > 0 and config.rock_matrix.pressure_sensitivity:
-            # Inputs must be numpy arrays, not masked arrays
-            vp, vs, rho_sat, _, _ = carbonate_pressure_model(
-                tmp_fl_prop_rho,
-                vp.data,
-                vs.data,
-                rho_sat,
-                vp.data,
-                vs.data,
-                rho_sat,
-                tmp_por,
-                tmp_pres_over,
-                tmp_pres_form,
-                tmp_pres_depl,
-                pres_model_vp,
-                pres_model_vs,
-                config.paths.rel_path_pem.absolute(),
-                False,
+        # Perform pressure correction on dry rock properties
+        if time_step > 0 and rock_matrix.pressure_sensitivity:
+            # Prepare in-situ properties dictionary based on what we have
+            in_situ_dict = {
+                ParameterTypes.K.value: k_dry,
+                ParameterTypes.MU.value: mu,
+                ParameterTypes.RHO.value: rho_dry,
+                ParameterTypes.POROSITY.value: tmp_por,
+            }
+
+            mineral_props = None
+            cement_props = None
+
+            # Regression model requirements are met as default, but in the case of a
+            # "physics model" (friable or patchy cement), extra matrix properties are
+            # needed
+            if hasattr(
+                rock_matrix.pressure_sensitivity_model, "model_type"
+            ) and rock_matrix.pressure_sensitivity_model.model_type in list(
+                PhysicsPressureModelTypes
+            ):
+                # Create mineral properties from matrix properties
+                mineral_props = EffectiveMineralProperties(
+                    bulk_modulus=tmp_min_k,
+                    shear_modulus=tmp_min_mu,
+                    density=tmp_min_rho,
+                )
+
+                # If patchy cement model, create cement properties
+                if (
+                    rock_matrix.pressure_sensitivity_model.model_type
+                    == PhysicsPressureModelTypes.PATCHY_CEMENT
+                ):
+                    # Use specified cement mineral
+                    cement_props = rock_matrix.minerals[rock_matrix.cement]
+
+            # Apply pressure sensitivity model
+            depleted_props = apply_dry_rock_pressure_sensitivity_model(
+                model=rock_matrix.pressure_sensitivity_model,
+                initial_eff_pressure=(
+                    tmp_pres_over - tmp_pres_form
+                ),  # effective initial pressure
+                depleted_eff_pressure=(
+                    tmp_pres_over - tmp_pres_depl
+                ),  # effective depleted pressure
+                in_situ_dict=in_situ_dict,
+                mineral_properties=mineral_props,
+                cement_properties=cement_props,
             )
-        vp, vs, rho_sat = reverse_filter_and_restore(mask, vp, vs, rho_sat)
-        props = SaturatedRockProperties(vp=vp, vs=vs, dens=rho_sat)
-        saturated_props.append(props)
 
-    return saturated_props
+            # Update dry properties with pressure-corrected values
+            k_dry = depleted_props[ParameterTypes.K.value]
+            mu = depleted_props[ParameterTypes.MU.value]
+            rho_dry = depleted_props[ParameterTypes.RHO.value]
+
+        # Saturate rock
+        k_sat = gassmann(k_dry, tmp_por, tmp_fl_prop_k, tmp_min_k)
+        rho_sat = rho_dry + tmp_por * tmp_fl_prop_rho
+        vp, vs = velocity(k_sat, mu, rho_sat)[0:2]
+
+        vp, vs, rho_sat, k_dry, mu, rho_dry = reverse_filter_and_restore(
+            mask, vp, vs, rho_sat, k_dry, mu, rho_dry
+        )
+        saturated_props.append(SaturatedRockProperties(vp=vp, vs=vs, density=rho_sat))
+        dry_props.append(
+            DryRockProperties(bulk_modulus=k_dry, shear_modulus=mu, density=rho_dry)
+        )
+
+    return saturated_props, dry_props

fmu/pem/pem_functions/run_friable_model.py

@@ -1,27 +1,36 @@
 from dataclasses import asdict
-from typing import List, Union
 
 import numpy as np
-from rock_physics_open.sandstone_models import friable_model
+from rock_physics_open.equinor_utilities.std_functions import (
+    gassmann,
+    velocity,
+)
+from rock_physics_open.sandstone_models import friable_model_dry
 
 from fmu.pem.pem_utilities import (
+    DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
-    PemConfig,
+    EffectiveMineralProperties,
     PressureProperties,
+    RockMatrixProperties,
     SaturatedRockProperties,
     filter_and_one_dim,
     reverse_filter_and_restore,
 )
+from fmu.pem.pem_utilities.enum_defs import (
+    ParameterTypes,
+)
+
+from .pressure_sensitivity import apply_dry_rock_pressure_sensitivity_model
 
 
 def run_friable(
-    mineral: MatrixProperties,
-    fluid: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
+    mineral: EffectiveMineralProperties,
+    fluid: list[EffectiveFluidProperties] | EffectiveFluidProperties,
     porosity: np.ma.MaskedArray,
-    pressure: Union[list[PressureProperties], PressureProperties],
-    config: PemConfig,
-) -> List[SaturatedRockProperties]:
+    pressure: list[PressureProperties] | PressureProperties,
+    rock_matrix: RockMatrixProperties,
+) -> tuple[list[SaturatedRockProperties], list[DryRockProperties]]:
     """
     Prepare inputs and parameters for running the Friable sandstone model
 
@@ -30,19 +39,32 @@ def run_friable(
         fluid: fluid properties containing k [Pa] and rho [kg/m3], can be several fluid
             properties in a list
         porosity: porosity fraction
-        pressure: steps in effective pressure in [bar] due to Eclipse standard
-        config: parameters for the PEM
+        pressure: steps in effective pressure, unit Pa
+        rock_matrix: parameters rock matrix
 
     Returns:
         saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3], ai
         (vp * density), si (vs * density), vpvs (vp / vs)
+        dry rock properties with bulk modulus [Pa], shear modulus [Pa] and density
+        [kg/m^3]
     """
     # Mineral and porosity are assumed to be single objects, fluid and
     # effective_pressure can be lists
     fluid, pressure = _verify_inputs(fluid, pressure)
+
+    # Depletion is calculated from the initial effective pressure
+    initial_effective_pressure = pressure[0].effective_pressure
+    # Container for saturated properties
     saturated_props = []
-    friable_params = config.rock_matrix.rpm.parameters
-    for fl_prop, pres in zip(fluid, pressure):
+    dry_props = []
+
+    # to please the IDE:
+    k_dry = None
+    mu = None
+    k_init = None
+    mu_init = None
+
+    for time_step, (fl_prop, pres) in enumerate(zip(fluid, pressure)):
         (
             mask,
             tmp_min_k,
@@ -52,37 +74,84 @@ def run_friable(
             tmp_fl_prop_rho,
             tmp_por,
             tmp_pres,
+            init_press,
         ) = filter_and_one_dim(
             mineral.bulk_modulus,
             mineral.shear_modulus,
-            mineral.dens,
+            mineral.density,
             fl_prop.bulk_modulus,
-            fl_prop.dens,
+            fl_prop.density,
             porosity,
-            pres.effective_pressure * 1.0e5,
+            pres.effective_pressure,
+            initial_effective_pressure,
+            return_numpy_array=True,
         )
-        """Estimation of effective mineral properties must be able to handle cases where
-         there is a more complex combination of minerals than the standard sand/shale
-         case. For carbonates the input can be based on minerals (e.g. calcite,
-         dolomite, quartz, smectite, ...) or PRTs (petrophysical rock types) that each
-         have been assigned elastic properties to."""
-        vp, vs, rho, _, _ = friable_model(
-            tmp_min_k,
-            tmp_min_mu,
-            tmp_min_rho,
-            tmp_fl_prop_k,
-            tmp_fl_prop_rho,
-            tmp_por,
-            tmp_pres,
-            friable_params.critical_porosity,
-            friable_params.coord_num_function,
-            friable_params.coordination_number,
-            friable_params.shear_reduction,
+        # At initial pressure, there is no need to estimate pressure effect on dry rock.
+        # If there is no pressure sensitivity, we use the initial pressure for the dry
+        # rock also after start of production, and the only differences will be due to
+        # changes in fluid properties or saturation
+        if time_step == 0:
+            k_dry, mu = friable_model_dry(
+                k_min=tmp_min_k,
+                mu_min=tmp_min_mu,
+                phi=tmp_por,
+                p_eff=init_press,
+                phi_c=rock_matrix.model.parameters.critical_porosity,
+                coord_num_func=rock_matrix.model.parameters.coordination_number_function,
+                n=rock_matrix.model.parameters.coord_num,
+                shear_red=rock_matrix.model.parameters.shear_reduction,
+            )
+            # For use at depleted pressure
+            k_init = k_dry
+            mu_init = mu
+        if time_step > 0 and rock_matrix.pressure_sensitivity:
+            # estimate the properties for the initial pressure by friable model,
+            # then apply correction for depletion
+
+            # Prepare in situ properties
+            in_situ_dict = {
+                ParameterTypes.K.value: k_init,
+                ParameterTypes.MU.value: mu_init,
+                ParameterTypes.RHO.value: tmp_min_rho,
+                ParameterTypes.POROSITY.value: tmp_por,
+            }
+            tmp_matrix = EffectiveMineralProperties(
+                bulk_modulus=tmp_min_k,
+                shear_modulus=tmp_min_mu,
+                density=tmp_min_rho,
+            )
+            depl_props = apply_dry_rock_pressure_sensitivity_model(
+                model=rock_matrix.pressure_sensitivity_model,
+                initial_eff_pressure=init_press,
+                depleted_eff_pressure=tmp_pres,
+                in_situ_dict=in_situ_dict,
+                mineral_properties=tmp_matrix,
+                cement_properties=rock_matrix.minerals[rock_matrix.cement],
+            )
+            k_dry = depl_props[ParameterTypes.K.value]
+            mu = depl_props[ParameterTypes.MU.value]
+
+        # Saturate rock
+        k_sat = gassmann(k_dry, tmp_por, tmp_fl_prop_k, tmp_min_k)
+        rho_dry = (1.0 - tmp_por) * tmp_min_rho
+        rho_sat = rho_dry + tmp_por * tmp_fl_prop_rho
+        vp, vs = velocity(k_sat, mu, rho_sat)[0:2]
+
+        # Restore original size and shape
+        vp, vs, rho_sat, k_dry, mu, rho_dry = reverse_filter_and_restore(
+            mask, vp, vs, rho_sat, k_dry, mu, rho_dry
         )
-        vp, vs, rho = reverse_filter_and_restore(mask, vp, vs, rho)
-        props = SaturatedRockProperties(vp=vp, vs=vs, dens=rho)
-        saturated_props.append(props)
-    return saturated_props
+        # Add results to list
+        saturated_props.append(SaturatedRockProperties(vp=vp, vs=vs, density=rho_sat))
+        dry_props.append(
+            DryRockProperties(
+                bulk_modulus=k_dry,
+                shear_modulus=mu,
+                density=(1.0 - tmp_por) * tmp_min_rho,
+            )
+        )
+
+    return saturated_props, dry_props
 
 
 def _verify_inputs(fl_prop, pres_prop):