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

fmu/pem/pem_functions/mineral_properties.py

@@ -1,16 +1,9 @@
 """
 Effective mineral properties are calculated from the individual mineral properties of
-the volume fractions. In the case that only a single net-to-gross fraction is
-available, this is transformed to shale and sand fractions. A net-to-gross fraction
-can also be estimated from porosity property.
-
-If the ntg_calculation_flag is set in the PEM configuration parameter file, this will
-override settings for volume fractions. In that case net-to-gross fraction is either
-read from file, or calculated from porosity.
+the volume fractions.
 """
 
 from pathlib import Path
-from typing import List, Tuple, Union
 from warnings import warn
 
 import numpy as np
@@ -18,70 +11,68 @@ from rock_physics_open.equinor_utilities.std_functions import (
     multi_hashin_shtrikman,
     multi_voigt_reuss_hill,
 )
+from xtgeo import Grid
 
 from fmu.pem.pem_utilities import (
-    MatrixProperties,
+    EffectiveMineralProperties,
     PemConfig,
+    RockMatrixProperties,
     SimInitProperties,
     filter_and_one_dim,
     get_shale_fraction,
     import_fractions,
-    ntg_to_shale_fraction,
-    read_ntg_grid,
     reverse_filter_and_restore,
     to_masked_array,
 )
-from fmu.pem.pem_utilities.enum_defs import MineralMixModel, VolumeFractions
+from fmu.pem.pem_utilities.enum_defs import MineralMixModel
 from fmu.pem.pem_utilities.pem_config_validation import (
     MineralProperties,
 )
 
 
 def effective_mineral_properties(
-    root_dir: Path, config: PemConfig, sim_init: SimInitProperties
-) -> Tuple[Union[np.ma.MaskedArray, None], MatrixProperties]:
+    root_dir: Path,
+    matrix: RockMatrixProperties,
+    sim_init: SimInitProperties,
+    sim_grid: Grid,
+) -> tuple[np.ma.MaskedArray | None, EffectiveMineralProperties]:
     """Estimate effective mineral properties for each grid cell
 
     Args:
         root_dir: start directory for running of PEM
-        config: configuration parameters
+        matrix: rock matrix parameters
         sim_init: simulation initial properties
 
     Returns:
         shale volume, effective mineral properties
     """
-    if config.rock_matrix.volume_fractions.mode == VolumeFractions.NTG_SIM:
-        # ntg_from_init_file flag takes precedence over ntg_from_porosity
-        if config.rock_matrix.volume_fractions.from_porosity:
-            vsh = calc_ntg_from_porosity(sim_init.poro)
-        else:
-            vsh = ntg_to_shale_fraction(sim_init.ntg, sim_init.poro)
-        fractions = [
-            vsh,
-        ]
-    else:
-        fractions = import_fractions(root_dir, config)
-        # In case of a single fraction: it can either be NTG or a true volume fraction
-        if len(fractions) == 1 and config.rock_matrix.volume_fractions.fraction_is_ntg:
-            fractions[0] = ntg_to_shale_fraction(fractions[0], sim_init.poro)
-        vsh = get_shale_fraction(
-            fractions,
-            config.rock_matrix.fraction_names,
-            config.rock_matrix.shale_fractions,
-        )
+    fractions = import_fractions(
+        root_dir=root_dir,
+        fraction_path=matrix.volume_fractions.rel_path_fractions,
+        fraction_files=matrix.volume_fractions.fractions_prop_file_names,
+        fraction_names=matrix.fraction_names,
+        grd=sim_grid,
+    )
+
+    vsh = get_shale_fraction(
+        fractions,
+        matrix.fraction_names,
+        matrix.shale_fractions,
+    )
 
-    mineral_names = config.rock_matrix.fraction_minerals
+    mineral_names = matrix.fraction_minerals
     eff_min_props = estimate_effective_mineral_properties(
-        mineral_names, fractions, config
+        mineral_names, fractions, matrix, sim_init.poro
     )
     return vsh, eff_min_props
 
 
 def estimate_effective_mineral_properties(
-    fraction_names: Union[str, List[str]],
-    fractions: Union[np.ma.MaskedArray, List[np.ma.MaskedArray]],
-    pem_config: PemConfig,
-) -> MatrixProperties:
+    fraction_names: str | list[str],
+    fractions: np.ma.MaskedArray | list[np.ma.MaskedArray],
+    matrix_params: RockMatrixProperties,
+    porosity: np.ma.MaskedArray,
+) -> EffectiveMineralProperties:
     """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,
@@ -101,12 +92,16 @@ def estimate_effective_mineral_properties(
     verify_mineral_inputs(
         fraction_names,
         fractions,
-        pem_config.rock_matrix.minerals,
-        pem_config.rock_matrix.complement,
+        matrix_params.minerals,
+        matrix_params.complement,
     )
 
     fraction_names, fractions = normalize_mineral_fractions(
-        fraction_names, fractions, pem_config.rock_matrix.complement
+        fraction_names,
+        fractions,
+        matrix_params.complement,
+        porosity,
+        matrix_params.volume_fractions.fractions_are_mineral_fraction,
     )
 
     mask, *fractions = filter_and_one_dim(*fractions)
@@ -114,12 +109,12 @@ def estimate_effective_mineral_properties(
     mu_list = []
     rho_list = []
     for name in fraction_names:
-        mineral = pem_config.rock_matrix.minerals[name]
+        mineral = matrix_params.minerals[name]
         k_list.append(to_masked_array(mineral.bulk_modulus, fractions[0]))
         mu_list.append(to_masked_array(mineral.shear_modulus, fractions[0]))
         rho_list.append(to_masked_array(mineral.density, fractions[0]))
 
-    if pem_config.rock_matrix.mineral_mix_model == MineralMixModel.HASHIN_SHTRIKMAN:
+    if matrix_params.mineral_mix_model == MineralMixModel.HASHIN_SHTRIKMAN:
         eff_k, eff_mu = multi_hashin_shtrikman(
             *[arr for prop in zip(k_list, mu_list, fractions) for arr in prop]
         )
@@ -134,8 +129,8 @@ def estimate_effective_mineral_properties(
     eff_min_k, eff_min_mu, eff_min_rho = reverse_filter_and_restore(
         mask, eff_k, eff_mu, eff_rho
     )
-    return MatrixProperties(
-        bulk_modulus=eff_min_k, shear_modulus=eff_min_mu, dens=eff_min_rho
+    return EffectiveMineralProperties(
+        bulk_modulus=eff_min_k, shear_modulus=eff_min_mu, density=eff_min_rho
     )
 
 
@@ -166,9 +161,14 @@ def normalize_mineral_fractions(
     names: str | list[str],
     fracs: np.ma.MaskedArray | list[np.ma.MaskedArray],
     complement: str,
-) -> Tuple[list[str], list[np.ma.MaskedArray]]:
+    porosity: np.ma.MaskedArray,
+    mineral_fractions: bool,
+) -> tuple[list[str], list[np.ma.MaskedArray]]:
     """Normalizes mineral fractions and adds complement mineral if needed.
 
+    If the fractions are volume fractions, porosity must be taken into account
+    when the fractions are normalized.
+
     When the sum of specified mineral fractions is less than 1.0, adds the complement
     mineral to make up the remainder. For example, if shale is 0.6 (60%) and the
     complement mineral is quartz, then quartz will be added at 0.4 (40%) to reach 100%.
@@ -182,49 +182,52 @@ def normalize_mineral_fractions(
         complement: Name of mineral to use as complement if sum < 1.0
 
     Returns:
-        Tuple containing:
-            - List of mineral names (with complement added if needed)
-            - List of normalized mineral fractions as masked arrays
+        tuple containing:
+            - list of mineral names (with complement added if needed)
+            - list of normalized mineral fractions as masked arrays
     """
-    if isinstance(names, str):
-        names = [names]
+    # Decide the mode of normalization - volume or mineral fractions
+    normalize_sum = 1.0 if mineral_fractions else 1.0 - porosity
 
-    if isinstance(fracs, np.ma.MaskedArray):
-        fracs = [fracs]
+    # Check for single or list of names and fractions
+    names = [names] if isinstance(names, str) else names
+    fracs = [fracs] if isinstance(fracs, np.ma.MaskedArray) else fracs
 
+    # Demand values in the range [0.0, 1.0]
     for i, frac in enumerate(fracs):
-        if np.any(frac[~frac.mask] < 0.0) or np.any(frac[~frac.mask] > 1.0):
+        if np.any(frac < 0.0) or np.any(frac > 1.0):
             warn(
-                f"mineral fraction {names[i]} has values outside of range 0.0 to 1.0,"
+                f"fraction {names[i]} has values outside of range 0.0 to 1.0,"
                 f"clipped to range",
                 UserWarning,
             )
             fracs[i] = np.ma.MaskedArray(np.ma.clip(frac, 0.0, 1.0))
 
-    tot_fractions = np.ma.sum(fracs, axis=0)
-    max_fraction = np.ma.max(tot_fractions)
-    TOLERANCE = 0.00001
-
-    if np.any(tot_fractions[~tot_fractions.mask] > 1.0 + TOLERANCE):
+    # Adjust values so that no cells exceed normalize_sum
+    tot_fractions = sum(fracs)
+    if np.ma.any(tot_fractions > normalize_sum):
         warn(
-            f"sum of mineral fractions are above 1.0 for "
-            f"{np.sum(tot_fractions[~tot_fractions.mask] > 1.0)} cells, is "
-            f"scaled to maximum 1.0.\n"
-            f"Max value is {np.max(tot_fractions[~tot_fractions.mask])}",
+            "sum of fractions has values above limit, rescaled to range",
             UserWarning,
         )
+        scale_factor = np.ma.max(tot_fractions / normalize_sum)
         for i, frac in enumerate(fracs):
-            fracs[i] /= max_fraction
+            fracs[i] /= scale_factor
 
-    comp_fraction = 1.0 - np.ma.sum(fracs, axis=0)
+    # Add a complement fraction if needed
+    comp_fraction = normalize_sum - sum(fracs)
     if np.any(comp_fraction > 0.0):
         names = names + [complement]
         fracs = fracs + [comp_fraction]
 
-    return names, fracs
-
+    # Rescale from volume fractions to mineral fractions if needed
+    if not mineral_fractions:
+        for i, frac in enumerate(fracs):
+            fracs[i] /= normalize_sum
 
-def calc_ntg_from_porosity(porosity: np.ma.MaskedArray) -> np.ma.MaskedArray:
-    vsh = to_masked_array(0, porosity)
-    vsh[porosity <= 0.33] = np.ma.power((0.33 - porosity[porosity < 0.33]) / 0.33, 2.0)
-    return (vsh / (1.0 - porosity)).clip(0.0, 1.0)
+    # Final check that all fractions sum to 1.0 for all cells
+    try:
+        np.testing.assert_allclose(sum(fracs), 1.0, rtol=1.0e-6, atol=1.0e-6)
+    except AssertionError as e:
+        raise ValueError(f"mineral fractions do not sum to 1: {e}") from e
+    return names, fracs

fmu/pem/pem_functions/pressure_sensitivity.py

@@ -0,0 +1,430 @@
+# python
+# File: src/fmu/pem/pem_functions/pressure_sensitivity.py
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Protocol, runtime_checkable
+
+import numpy as np
+
+from fmu.pem.pem_utilities.enum_defs import (
+    ParameterTypes,
+    PhysicsPressureModelTypes,
+    RegressionPressureParameterTypes,
+)
+from fmu.pem.pem_utilities.pem_class_definitions import EffectiveMineralProperties
+from fmu.pem.pem_utilities.rpm_models import (
+    MineralProperties,
+    PhysicsModelPressureSensitivity,
+    RegressionPressureSensitivity,
+)
+
+_FEATURE_NAME_MAP = {
+    ParameterTypes.VP.value: "VP",
+    ParameterTypes.VS.value: "VSX",  # Model expects VSX for Vs
+    ParameterTypes.K.value: "K",
+    ParameterTypes.MU.value: "MU",
+}
+
+
+@runtime_checkable
+class RegressionPressureModel(Protocol):
+    """Protocol for regression-based pressure sensitivity models."""
+
+    mode: RegressionPressureParameterTypes
+
+    def predict_elastic_properties(
+        self,
+        prop1: np.ndarray,
+        prop2: np.ndarray,
+        in_situ_press: np.ndarray,
+        depl_press: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray]: ...
+
+
+@runtime_checkable
+class PhysicsPressureModel(Protocol):
+    """Protocol for physics-based pressure sensitivity models."""
+
+    model_type: PhysicsPressureModelTypes
+
+    def predict_elastic_properties(
+        self,
+        k_dry: np.ndarray,
+        mu_dry: np.ndarray,
+        poro: np.ndarray,
+        min_prop: MineralProperties,
+        in_situ_press: np.ndarray,
+        depl_press: np.ndarray,
+        cem_prop: MineralProperties | None = None,
+    ) -> tuple[np.ndarray, np.ndarray]: ...
+
+
+def _validate_array_shapes(
+    *arrays: np.ndarray,
+    names: list[str] | None = None,
+) -> None:
+    """
+    Validate that all arrays have the same first dimension.
+
+    Parameters
+    ----------
+    *arrays : np.ndarray
+        Arrays to validate.
+    names : list[str] | None
+        Names for error messages. If None, uses generic labels.
+
+    Raises
+    ------
+    PressureSensitivityInputError
+        If array shapes are inconsistent.
+    """
+    if not arrays:
+        return
+
+    expected_shape = arrays[0].shape[0]
+    names = names or [f"array_{i}" for i in range(len(arrays))]
+
+    for arr, name in zip(arrays, names):
+        if arr.shape[0] != expected_shape:
+            raise PressureSensitivityInputError(
+                f"Shape mismatch for '{name}': expected {expected_shape}, "
+                f"got {arr.shape[0]}"
+            )
+
+
+def _validate_required_keys(
+    provided: dict[str, np.ndarray],
+    required: set[str],
+    dict_name: str,
+) -> None:
+    """
+    Validate that all required keys exist in provided dictionary.
+
+    Parameters
+    ----------
+    provided : dict[str, np.ndarray]
+        Dictionary to validate.
+    required : set[str]
+        Required keys.
+    dict_name : str
+        Name for error messages.
+
+    Raises
+    ------
+    PressureSensitivityInputError
+        If any required key is missing.
+    """
+    missing = required - set(provided.keys())
+    if missing:
+        raise PressureSensitivityInputError(
+            f"Missing keys {sorted(missing)} in {dict_name}; "
+            f"required={sorted(required)}"
+        )
+
+
+def _extract_input_properties(
+    in_situ_dict: dict[str, np.ndarray],
+    mode: RegressionPressureParameterTypes,
+    rho: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Extract or compute the two elastic properties needed for the model.
+
+    Parameters
+    ----------
+    in_situ_dict : dict[str, np.ndarray]
+        Dictionary with in-situ properties. Must contain either (vp, vs) or (k, mu).
+    mode : RegressionPressureParameterTypes
+        Model mode determining which properties are needed.
+    rho : np.ndarray
+        Density array for conversions.
+
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray]
+        (prop1, prop2) matching the model mode:
+        - VP_VS mode: (vp, vs)
+        - K_MU mode: (k, mu)
+
+    Raises
+    ------
+    PressureSensitivityInputError
+        If required properties cannot be obtained.
+    """
+    from rock_physics_open.equinor_utilities.std_functions import moduli, velocity
+
+    vp_key = ParameterTypes.VP.value
+    vs_key = ParameterTypes.VS.value
+    k_key = ParameterTypes.K.value
+    mu_key = ParameterTypes.MU.value
+
+    has_velocities = vp_key in in_situ_dict and vs_key in in_situ_dict
+    has_moduli = k_key in in_situ_dict and mu_key in in_situ_dict
+
+    if mode == RegressionPressureParameterTypes.VP_VS:
+        if has_velocities:
+            return in_situ_dict[vp_key], in_situ_dict[vs_key]
+        if has_moduli:
+            # Convert from moduli to velocities
+            vp, vs = velocity(in_situ_dict[k_key], in_situ_dict[mu_key], rho)[0:2]
+            return vp, vs
+        raise PressureSensitivityInputError(
+            f"For VP_VS mode, need either ({vp_key}, {vs_key}) or ({k_key}, {mu_key})"
+        )
+    # K_MU mode
+    if has_moduli:
+        return in_situ_dict[k_key], in_situ_dict[mu_key]
+    if has_velocities:
+        # Convert from velocities to moduli
+        k, mu = moduli(in_situ_dict[vp_key], in_situ_dict[vs_key], rho)
+        return k, mu
+    raise PressureSensitivityInputError(
+        f"For K_MU mode, need either ({k_key}, {mu_key}) or ({vp_key}, {vs_key})"
+    )
+
+
+def _compute_all_elastic_properties(
+    prop1: np.ndarray,
+    prop2: np.ndarray,
+    rho: np.ndarray,
+    mode: RegressionPressureParameterTypes,
+) -> dict[str, np.ndarray]:
+    """
+    Compute all four elastic properties from the two predicted ones.
+
+    Parameters
+    ----------
+    prop1 : np.ndarray
+        First predicted property (vp or k).
+    prop2 : np.ndarray
+        Second predicted property (vs or mu).
+    rho : np.ndarray
+        Density array.
+    mode : RegressionPressureParameterTypes
+        Model mode indicating which properties were predicted.
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        Dictionary containing vp, vs, k, mu, and rho.
+    """
+    from rock_physics_open.equinor_utilities.std_functions import moduli, velocity
+
+    if mode == RegressionPressureParameterTypes.VP_VS:
+        vp, vs = prop1, prop2
+        k, mu = moduli(vp, vs, rho)
+    else:  # K_MU mode
+        k, mu = prop1, prop2
+        vp, vs = velocity(k, mu, rho)[0:2]
+
+    return {
+        ParameterTypes.VP.value: vp,
+        ParameterTypes.VS.value: vs,
+        ParameterTypes.K.value: k,
+        ParameterTypes.MU.value: mu,
+        ParameterTypes.RHO.value: rho,
+    }
+
+
+class PressureSensitivityInputError(ValueError):
+    """Raised when required pressure sensitivity inputs are missing or inconsistent."""
+
+
+def _validate_required(
+    provided: dict[str, np.ndarray],
+    required: Iterable[str],
+    dict_name: str,
+) -> None:
+    """
+    Validate that all required keys exist in a provided dictionary.
+
+    Parameters
+    ----------
+    provided : dict[str, np.ndarray]
+        Dictionary containing arrays for rock properties.
+    required : Iterable[str]
+        Keys that must be present.
+    dict_name : str
+        Name used in error messages.
+
+    Raises
+    ------
+    PressureSensitivityInputError
+        If any required key is missing.
+    """
+    missing = [k for k in required if k not in provided]
+    if missing:
+        raise PressureSensitivityInputError(
+            f"Missing keys {missing} in {dict_name}; required={list(required)}"
+        )
+
+
+def _as_enum_mode(
+    mode: RegressionPressureParameterTypes | str,
+) -> RegressionPressureParameterTypes:
+    """
+    Normalize mode argument to RegressionPressureParameterTypes enum.
+
+    Parameters
+    ----------
+    mode : RegressionPressureParameterTypes | str
+        Mode specification ('vp_vs' or 'k_mu').
+
+    Returns
+    -------
+    RegressionPressureParameterTypes
+        Normalized enum value.
+
+    Raises
+    ------
+    ValueError
+        If unsupported mode supplied.
+    """
+    if isinstance(mode, RegressionPressureParameterTypes):
+        return mode
+    try:
+        return RegressionPressureParameterTypes(mode)
+    except ValueError as exc:
+        raise ValueError(
+            f"Unsupported mode '{mode}'. Expected 'vp_vs' or 'k_mu'."
+        ) from exc
+
+
+def apply_dry_rock_pressure_sensitivity_model(
+    model: RegressionPressureSensitivity | PhysicsModelPressureSensitivity,
+    initial_eff_pressure: np.ndarray,
+    depleted_eff_pressure: np.ndarray,
+    in_situ_dict: dict[str, np.ndarray],
+    mineral_properties: MineralProperties | EffectiveMineralProperties | None = None,
+    cement_properties: MineralProperties | EffectiveMineralProperties | None = None,
+) -> dict[str, np.ndarray]:
+    """
+    Apply pressure sensitivity model to estimate depleted elastic properties.
+
+    Handles both regression-based and physics-based pressure sensitivity models
+    with their different input requirements.
+
+    Parameters
+    ----------
+    model : RegressionPressureSensitivity | PhysicsModelPressureSensitivity
+        Pressure sensitivity model instance.
+    initial_eff_pressure : np.ndarray
+        In-situ effective (pore) pressure [Pa], shape (n,).
+    depleted_eff_pressure : np.ndarray
+        Depleted effective pressure [Pa], shape (n,).
+    in_situ_dict : dict[str, np.ndarray]
+        Dictionary with in-situ properties. Must contain 'rho'.
+        For regression models: requires ('vp', 'vs') or ('k', 'mu').
+        For physics models: requires ('k', 'mu', 'porosity').
+    mineral_properties : MineralProperties | None
+        Required for physics-based models. Mineral elastic properties.
+    cement_properties : MineralProperties | None
+        Required for patchy cement physics model.
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        Dictionary with 'vp', 'vs', 'k', 'mu', 'rho'.
+
+    Raises
+    ------
+    PressureSensitivityInputError
+        If required inputs are missing or inconsistent.
+    """
+    # Validate common inputs
+    _validate_required_keys(in_situ_dict, {ParameterTypes.RHO.value}, "in_situ_dict")
+    rho = in_situ_dict[ParameterTypes.RHO.value]
+
+    # Route to appropriate handler based on model type
+    if isinstance(model, RegressionPressureSensitivity):
+        return _apply_regression_model(
+            model, in_situ_dict, rho, initial_eff_pressure, depleted_eff_pressure
+        )
+    if isinstance(model, PhysicsModelPressureSensitivity):
+        return _apply_physics_model(
+            model,
+            in_situ_dict,
+            rho,
+            initial_eff_pressure,
+            depleted_eff_pressure,
+            mineral_properties,
+            cement_properties,
+        )
+    raise TypeError(f"Unsupported model type: {type(model)}")
+
+
+def _apply_regression_model(
+    model: RegressionPressureSensitivity,
+    in_situ_dict: dict[str, np.ndarray],
+    rho: np.ndarray,
+    pres_in_situ: np.ndarray,
+    pres_depleted: np.ndarray,
+) -> dict[str, np.ndarray]:
+    """Apply regression-based pressure sensitivity model."""
+    # Extract or compute input properties matching model mode
+    prop1_in_situ, prop2_in_situ = _extract_input_properties(
+        in_situ_dict, model.mode, rho
+    )
+
+    # Predict depleted properties
+    prop1_depleted, prop2_depleted = model.predict_elastic_properties(
+        prop1_in_situ, prop2_in_situ, pres_in_situ, pres_depleted
+    )
+
+    # Compute all elastic properties
+    return _compute_all_elastic_properties(
+        prop1_depleted, prop2_depleted, rho, model.mode
+    )
+
+
+def _apply_physics_model(
+    model: PhysicsModelPressureSensitivity,
+    in_situ_dict: dict[str, np.ndarray],
+    rho: np.ndarray,
+    pres_in_situ: np.ndarray,
+    pres_depleted: np.ndarray,
+    mineral_properties: MineralProperties | EffectiveMineralProperties | None,
+    cement_properties: MineralProperties | EffectiveMineralProperties | None,
+) -> dict[str, np.ndarray]:
+    """Apply physics-based pressure sensitivity model."""
+    from rock_physics_open.equinor_utilities.std_functions import velocity
+
+    # Validate required inputs for physics models
+    if mineral_properties is None:
+        raise PressureSensitivityInputError(
+            "Physics-based models require mineral_properties"
+        )
+
+    required_keys = {
+        ParameterTypes.K.value,
+        ParameterTypes.MU.value,
+        ParameterTypes.POROSITY.value,
+    }
+    _validate_required_keys(in_situ_dict, required_keys, "in_situ_dict")
+
+    k_dry = in_situ_dict[ParameterTypes.K.value]
+    mu_dry = in_situ_dict[ParameterTypes.MU.value]
+    poro = in_situ_dict[ParameterTypes.POROSITY.value]
+
+    # Predict depleted moduli
+    k_depleted, mu_depleted = model.predict_elastic_properties(
+        k_dry=k_dry,
+        mu_dry=mu_dry,
+        poro=poro,
+        min_prop=mineral_properties,
+        in_situ_press=pres_in_situ,
+        depl_press=pres_depleted,
+        cem_prop=cement_properties,
+    )
+
+    # Convert to velocities
+    vp, vs = velocity(k_depleted, mu_depleted, rho)[0:2]
+
+    return {
+        ParameterTypes.VP.value: vp,
+        ParameterTypes.VS.value: vs,
+        ParameterTypes.K.value: k_depleted,
+        ParameterTypes.MU.value: mu_depleted,
+        ParameterTypes.RHO.value: rho,
+    }