fmu-pem 0.0.1__py3-none-any.whl

fmu/pem/pem_functions/regression_models.py

@@ -0,0 +1,261 @@
+"""Regression models for saturated sandstones
+
+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 (
+    gassmann,
+    hashin_shtrikman_average,
+    moduli,
+    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,
+    PressureProperties,
+    SaturatedRockProperties,
+    filter_and_one_dim,
+    reverse_filter_and_restore,
+)
+from fmu.pem.pem_utilities.enum_defs import MineralMixModel
+from fmu.pem.pem_utilities.rpm_models import (
+    KMuRegressionParams,
+    VpVsRegressionParams,
+)
+
+
+def gen_regression(
+    porosity: np.ndarray, polynom_weights: list | np.ndarray
+) -> np.ndarray:
+    """Regression model for Vp
+
+    Args:
+        porosity: porosity [fraction]
+        polynom_weights: weights for the polynomial regression model
+
+    Returns:
+        Vp [m/s]
+    """
+    pol = np.polynomial.Polynomial(polynom_weights)
+    return pol(porosity)
+
+
+def dry_rock_regression(
+    porosity: npt.NDArray[np.float64] | np.ma.MaskedArray,
+    rho_min: npt.NDArray[np.float64] | np.ma.MaskedArray,
+    params: VpVsRegressionParams | KMuRegressionParams,
+) -> DryRockProperties:
+    """
+    Calculates dry rock properties based on porosity and polynomial weights.
+
+    Args:
+        porosity: An array of porosity values.
+        rho_min: An array of mineral density values.
+        params: PemConfig object containing the regression model parameters.
+
+    Returns:
+        A dictionary with keys corresponding to the calculated properties and
+        their values.
+
+    Raises:
+        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
+        rho_dry = rho_min * (1 - porosity)
+    else:
+        rho_dry = gen_regression(porosity, params.rho_weights)
+
+    if (
+        params.mode == "vp_vs"
+        and params.vp_weights is not None
+        and params.vs_weights is not None
+    ):
+        vp_dry = gen_regression(porosity, params.vp_weights)
+        vs_dry = gen_regression(porosity, params.vs_weights)
+        k_dry, mu = moduli(vp_dry, vs_dry, rho_dry)
+    elif (
+        params.mode == "k_mu"
+        and params.k_weights is not None
+        and params.mu_weights is not None
+    ):
+        k_dry = gen_regression(porosity, params.k_weights)
+        mu = gen_regression(porosity, params.mu_weights)
+    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),
+    )
+
+
+def run_regression_models(
+    mineral: MatrixProperties,
+    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]:
+    """Run regression models for saturated rock properties.
+
+    Args:
+        mineral: Mineral properties containing bulk modulus (k) [Pa],
+            shear modulus (mu) [Pa] and density (rho_sat) [kg/m3]
+        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
+        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.
+            Only fluid properties change between time steps in this model.
+    """
+
+    saturated_props = []
+    tmp_pres_over = None
+    tmp_pres_form = None
+    tmp_pres_depl = None
+
+    if vsh is None:
+        vsh = np.ma.MaskedArray(
+            data=np.zeros_like(porosity), mask=np.zeros_like(porosity).astype(bool)
+        )
+        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
+    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
+            (
+                mask,
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_fl_prop_k,
+                tmp_fl_prop_rho,
+                tmp_por,
+                tmp_vsh,
+                tmp_pres_over,
+                tmp_pres_form,
+                tmp_pres_depl,
+            ) = filter_and_one_dim(
+                mineral.bulk_modulus,
+                mineral.shear_modulus,
+                mineral.dens,
+                fl_prop.bulk_modulus,
+                fl_prop.dens,
+                porosity,
+                vsh,
+                pres_ovb,
+                pres_form,
+                pres_depl,
+                return_numpy_array=True,
+            )
+        else:
+            (
+                mask,
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_fl_prop_k,
+                tmp_fl_prop_rho,
+                tmp_por,
+                tmp_vsh,
+            ) = filter_and_one_dim(
+                mineral.bulk_modulus,
+                mineral.shear_modulus,
+                mineral.dens,
+                fl_prop.bulk_modulus,
+                fl_prop.dens,
+                porosity,
+                vsh,
+            )
+        if not multiple_lithologies:
+            dry_props = dry_rock_regression(
+                tmp_por, tmp_min_rho, config.rock_matrix.rpm.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
+            )
+            dry_rho = (
+                dry_props_sand.dens * (1.0 - tmp_vsh) + dry_props_shale.dens * tmp_vsh
+            )
+            if config.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),
+                )
+            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),
+                )
+            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,
+            )
+        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

fmu/pem/pem_functions/run_friable_model.py

@@ -0,0 +1,119 @@
+from dataclasses import asdict
+from typing import List, Union
+
+import numpy as np
+from rock_physics_open.sandstone_models import friable_model
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    PressureProperties,
+    SaturatedRockProperties,
+    filter_and_one_dim,
+    reverse_filter_and_restore,
+)
+
+
+def run_friable(
+    mineral: MatrixProperties,
+    fluid: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
+    porosity: np.ma.MaskedArray,
+    pressure: Union[list[PressureProperties], PressureProperties],
+    config: PemConfig,
+) -> List[SaturatedRockProperties]:
+    """
+    Prepare inputs and parameters for running the Friable sandstone model
+
+    Args:
+        mineral: mineral properties containing k [Pa], mu [Pa] and rho [kg/m3]
+        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
+
+    Returns:
+        saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3], ai
+        (vp * density), si (vs * density), vpvs (vp / vs)
+    """
+    # Mineral and porosity are assumed to be single objects, fluid and
+    # effective_pressure can be lists
+    fluid, pressure = _verify_inputs(fluid, pressure)
+    saturated_props = []
+    friable_params = config.rock_matrix.rpm.parameters
+    for fl_prop, pres in zip(fluid, pressure):
+        (
+            mask,
+            tmp_min_k,
+            tmp_min_mu,
+            tmp_min_rho,
+            tmp_fl_prop_k,
+            tmp_fl_prop_rho,
+            tmp_por,
+            tmp_pres,
+        ) = filter_and_one_dim(
+            mineral.bulk_modulus,
+            mineral.shear_modulus,
+            mineral.dens,
+            fl_prop.bulk_modulus,
+            fl_prop.dens,
+            porosity,
+            pres.effective_pressure * 1.0e5,
+        )
+        """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,
+        )
+        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
+
+
+def _verify_inputs(fl_prop, pres_prop):
+    # Ensure that properties of input objects are masked arrays
+    def check_masked_arrays(inp_obj):
+        for value in inp_obj.values():
+            if not isinstance(value, np.ma.MaskedArray):
+                raise ValueError("Expected all input object values to be masked arrays")
+
+    if isinstance(fl_prop, list) and isinstance(pres_prop, list):
+        if not len(fl_prop) == len(pres_prop):
+            raise ValueError(
+                f"{__file__}: unequal steps in fluid properties and pressure: "
+                f"{len(fl_prop)} vs. {len(pres_prop)}"
+            )
+        for item in fl_prop + pres_prop:
+            check_masked_arrays(asdict(item))
+        return fl_prop, pres_prop
+    if isinstance(fl_prop, EffectiveFluidProperties) and isinstance(
+        pres_prop, PressureProperties
+    ):
+        check_masked_arrays(asdict(fl_prop))
+        check_masked_arrays(asdict(pres_prop))
+        return [
+            fl_prop,
+        ], [
+            pres_prop,
+        ]
+    # else:
+    raise ValueError(
+        f"{__file__}: mismatch between fluid and pressure objects, both should "
+        f"either be lists or class objects, are {type(fl_prop)} and "
+        f"{type(pres_prop)}"
+    )

fmu/pem/pem_functions/run_patchy_cement_model.py

@@ -0,0 +1,120 @@
+from typing import List, Union
+
+import numpy as np
+from rock_physics_open.sandstone_models import (
+    patchy_cement_model_cem_frac as patchy_cement,
+)
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    PressureProperties,
+    SaturatedRockProperties,
+    filter_and_one_dim,
+    reverse_filter_and_restore,
+)
+
+
+def run_patchy_cement(
+    mineral: MatrixProperties,
+    fluid: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
+    cement: MatrixProperties,
+    porosity: np.ma.MaskedArray,
+    pressure: Union[list[PressureProperties], PressureProperties],
+    config: PemConfig,
+) -> List[SaturatedRockProperties]:
+    """Prepare inputs and parameters for running the Patchy Cement model
+
+    Args:
+        mineral: mineral properties containing k [Pa], mu [Pa] and rho [kg/m3]
+        fluid: fluid properties containing k [Pa] and rho [kg/m3], can be several fluid
+            properties in a list
+        cement: cement properties containing k [Pa], mu [Pa] and rho [kg/m3]
+        porosity: porosity fraction
+        pressure: steps in effective pressure in [bar] due to Eclipse standard
+        config: parameters for the PEM
+
+    Returns:
+        saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3], ai
+        (vp * density), si (vs * density), vpvs (vp / vs)
+    """
+    # Mineral and porosity are assumed to be single objects, fluid and
+    # effective_pressure can be lists
+    fluid, pressure = _verify_inputs(fluid, pressure)
+    saturated_props = []
+    pat_cem_params = config.rock_matrix.rpm.parameters
+    for fl_prop, pres in zip(fluid, pressure):
+        (
+            mask,
+            tmp_min_k,
+            tmp_min_mu,
+            tmp_min_rho,
+            tmp_cem_k,
+            tmp_cem_mu,
+            tmp_cem_rho,
+            tmp_fl_prop_k,
+            tmp_fl_prop_rho,
+            tmp_por,
+            tmp_pres,
+        ) = filter_and_one_dim(
+            mineral.bulk_modulus,
+            mineral.shear_modulus,
+            mineral.dens,
+            cement.bulk_modulus,
+            cement.shear_modulus,
+            cement.dens,
+            fl_prop.bulk_modulus,
+            fl_prop.dens,
+            porosity,
+            pres.effective_pressure * 1.0e5,
+            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, _, _ = patchy_cement(
+            tmp_min_k,
+            tmp_min_mu,
+            tmp_min_rho,
+            tmp_cem_k,
+            tmp_cem_mu,
+            tmp_cem_rho,
+            tmp_fl_prop_k,
+            tmp_fl_prop_rho,
+            tmp_por,
+            tmp_pres,
+            pat_cem_params.cement_fraction,
+            pat_cem_params.critical_porosity,
+            pat_cem_params.coord_num_function,
+            pat_cem_params.coordination_number,
+            pat_cem_params.shear_reduction,
+        )
+        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
+
+
+def _verify_inputs(fl_prop, pres_prop):
+    if isinstance(fl_prop, list) and isinstance(pres_prop, list):
+        if not len(fl_prop) == len(pres_prop):
+            raise ValueError(
+                f"{__file__}: unequal steps in fluid properties and pressure: "
+                f"{len(fl_prop)} vs. {len(pres_prop)}"
+            )
+        return fl_prop, pres_prop
+    if isinstance(fl_prop, EffectiveFluidProperties) and (
+        isinstance(pres_prop, PressureProperties)
+    ):
+        return [
+            fl_prop,
+        ], [
+            pres_prop,
+        ]
+    raise ValueError(
+        f"{__file__}: mismatch between fluid and pressure objects, both should either "
+        f"be lists or single objects, are {type(fl_prop)} and {type(pres_prop)}"
+    )

fmu/pem/pem_functions/run_t_matrix_and_pressure.py

@@ -0,0 +1,186 @@
+from pathlib import Path
+from typing import List, Union
+
+import numpy as np
+from rock_physics_open.t_matrix_models import (
+    carbonate_pressure_model,
+    run_t_matrix_forward_model_with_opt_params_exp,
+    run_t_matrix_forward_model_with_opt_params_petec,
+)
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    PressureProperties,
+    SaturatedRockProperties,
+    filter_and_one_dim,
+    reverse_filter_and_restore,
+)
+
+from .run_patchy_cement_model import _verify_inputs
+
+
+def run_t_matrix_and_pressure_models(
+    mineral_properties: MatrixProperties,
+    fluid_properties: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
+    porosity: np.ma.MaskedArray,
+    vsh: Union[None, np.ma.MaskedArray],
+    pressure: Union[list[PressureProperties], PressureProperties],
+    config: PemConfig,
+    petec_parameter_file: Path = Path("t_mat_params_petec.pkl"),
+    exp_parameter_file: Path = Path("t_mat_params_exp.pkl"),
+    pres_model_vp: Path = Path("carbonate_pressure_model_vp_exp.pkl"),
+    pres_model_vs: Path = Path("carbonate_pressure_model_vs_exp.pkl"),
+) -> List[SaturatedRockProperties]:
+    """Model for carbonate rock with possibility to estimate changes due to
+    production, i.e., saturation changes, changes in the fluids due to pore pressure
+    change and also changes in the properties of the matrix by increase in effective
+    pressure.
+
+    The first timestep is regarded as in situ conditions for the pressure
+    substitution, any later timestep also takes into account the changes in effective
+    pressure from the initial one.
+
+    Calibration of parameters for the T-Matrix model must be made before running the
+    forward model, this is only possible in RokDoc with 1D match to logs.
+
+    Args:
+        mineral_properties: bulk modulus (k) [Pa], shear modulus (mu) [Pa],
+            density [kg/m^3]
+        fluid_properties: bulk modulus (k) [Pa] and density [kg/m^3] for each restart
+            date
+        porosity: porosity [fraction]
+        vsh: shale volume [fraction]
+        pressure: overburden, effective and formation (pore) pressure per restart date
+        config: configuration parameters
+        petec_parameter_file: additional parameters for the T-Matrix model, determined
+            through optimisation to well logs
+        exp_parameter_file: additional parameters for the T-Matrix model, determined
+            through optimisation to well logs
+        pres_model_vp: pressure sensitivity model for vp
+        pres_model_vs: pressure sensitivity model for vs
+
+    Returns:
+        saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3],
+        ai (vp * density), si (vs * density), vpvs (vp / vs)
+    """
+    fluid_properties, pressure = _verify_inputs(fluid_properties, pressure)
+
+    # All model files are gathered with the config file for the PEM model,
+    # i.e. in ../sim2seis/model
+    petec_parameter_file = config.paths.rel_path_pem / petec_parameter_file
+    exp_parameter_file = config.paths.rel_path_pem / exp_parameter_file
+
+    saturated_props = []
+    t_mat_params = config.rock_matrix.rpm.parameters
+
+    if vsh is None and t_mat_params.t_mat_model_version == "EXP":
+        raise ValueError("Shale volume must be provided for EXP model")
+    if vsh is None:
+        # For simplicity in the filtering, if no shale volume is provided, it is set
+        # to zero
+        vsh = np.ma.array(
+            np.zeros_like(porosity), mask=np.zeros_like(porosity).astype(bool)
+        )
+    # Change unit from bar to Pa
+    pres_ovb = pressure[0].overburden_pressure * 1.0e5
+    pres_form = pressure[0].formation_pressure * 1.0e5
+
+    for time_step, fl_prop in enumerate(fluid_properties):
+        if time_step > 0:
+            pres_depl = pressure[time_step].formation_pressure * 1.0e5
+            (
+                mask,
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_fl_k,
+                tmp_fl_rho,
+                tmp_por,
+                tmp_vsh,
+                tmp_pres_over,
+                tmp_pres_form,
+                tmp_pres_depl,
+            ) = filter_and_one_dim(
+                mineral_properties.bulk_modulus,
+                mineral_properties.shear_modulus,
+                mineral_properties.dens,
+                fl_prop.bulk_modulus,
+                fl_prop.dens,
+                porosity,
+                vsh,
+                pres_ovb,
+                pres_form,
+                pres_depl,
+            )
+        else:
+            tmp_pres_over, tmp_pres_form, tmp_pres_depl = (None, None, None)
+            (
+                mask,
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_fl_k,
+                tmp_fl_rho,
+                tmp_por,
+                tmp_vsh,
+            ) = filter_and_one_dim(
+                mineral_properties.bulk_modulus,
+                mineral_properties.shear_modulus,
+                mineral_properties.dens,
+                fl_prop.bulk_modulus,
+                fl_prop.dens,
+                porosity,
+                vsh,
+            )
+        if t_mat_params.t_mat_model_version == "PETEC":
+            vp, vs, rho, k, mu = run_t_matrix_forward_model_with_opt_params_petec(
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_fl_k,
+                tmp_fl_rho,
+                tmp_por,
+                t_mat_params.angle,
+                t_mat_params.perm,
+                t_mat_params.visco,
+                t_mat_params.tau,
+                t_mat_params.freq,
+                str(petec_parameter_file),
+            )
+        else:
+            vp, vs, rho, k, mu = run_t_matrix_forward_model_with_opt_params_exp(
+                tmp_fl_k,
+                tmp_fl_rho,
+                tmp_por,
+                tmp_vsh,
+                t_mat_params.angle,
+                t_mat_params.perm,
+                t_mat_params.visco,
+                t_mat_params.tau,
+                t_mat_params.freq,
+                str(exp_parameter_file),
+            )
+        if time_step > 0:
+            vp, vs, rho, _, _ = carbonate_pressure_model(
+                tmp_fl_rho,
+                vp,
+                vs,
+                rho,
+                vp,
+                vs,
+                rho,
+                tmp_por,
+                tmp_pres_over,
+                tmp_pres_form,
+                tmp_pres_depl,
+                pres_model_vp,
+                pres_model_vs,
+                config.paths.rel_path_pem.absolute(),
+                False,
+            )
+        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