fmu-pem 0.0.1__py3-none-any.whl

fmu/__init__.py

@@ -0,0 +1,2 @@
+# This line ONLY:
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

fmu/pem/__init__.py

@@ -0,0 +1,19 @@
+"""
+The INTERNAL_EQUINOR property means that fmu-pem is run within the Equinor organisation
+where there is access to more elaborate fluid models and other rock physics
+models.
+"""
+
+try:  # noqa: SIM105
+    import init_rock_physics
+except (ImportError, ModuleNotFoundError):
+    INTERNAL_EQUINOR = False
+else:
+    INTERNAL_EQUINOR = True
+
+from .run_pem import pem_fcn
+
+__all__ = [
+    "pem_fcn",
+    "INTERNAL_EQUINOR",
+]

fmu/pem/__main__.py

@@ -0,0 +1,53 @@
+# pylint: disable=missing-module-docstring
+import argparse
+from pathlib import Path
+from warnings import warn
+
+from .pem_utilities import restore_dir
+from .run_pem import pem_fcn
+
+
+def main():
+    parser = argparse.ArgumentParser(__file__)
+    parser.add_argument(
+        "-s",
+        "--startdir",
+        type=Path,
+        required=True,
+        help="Start directory for running script (required)",
+    )
+    parser.add_argument(
+        "-c",
+        "--configdir",
+        type=Path,
+        required=True,
+        help="Path to config file (required)",
+    )
+    parser.add_argument(
+        "-f",
+        "--configfile",
+        type=Path,
+        required=True,
+        help="Configuration yaml file name (required)",
+    )
+    args = parser.parse_args()
+    cwd = args.startdir
+    if str(cwd).endswith("rms/model"):
+        run_folder = cwd
+    else:
+        try:
+            run_folder = cwd.joinpath("rms/model")
+            assert run_folder.exists() and run_folder.is_dir()
+        except AssertionError as e:
+            warn(f"PEM model should be run from the rms/model folder. {e}")
+            run_folder = cwd
+    with restore_dir(run_folder):
+        pem_fcn(
+            start_dir=args.startdir,
+            rel_path_pem=args.configdir,
+            pem_config_file_name=args.configfile,
+        )
+
+
+if __name__ == "__main__":
+    main()

fmu/pem/forward_models/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .pem_model import PetroElasticModel
+
+__all__ = [
+    "PetroElasticModel",
+]

fmu/pem/forward_models/pem_model.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from ert import (
+    ForwardModelStepDocumentation,
+    ForwardModelStepJSON,
+    ForwardModelStepPlugin,
+    ForwardModelStepValidationError,
+)
+
+
+class PetroElasticModel(ForwardModelStepPlugin):
+    def __init__(self) -> None:
+        super().__init__(
+            name="PEM",
+            command=[
+                "pem",
+                "--startdir",
+                "<START_DIR>",
+                "--configdir",
+                "<CONFIG_DIR>",
+                "--configfile",
+                "<CONFIG_FILE>",
+            ],
+        )
+
+    def validate_pre_realization_run(
+        self, fm_step_json: ForwardModelStepJSON
+    ) -> ForwardModelStepJSON:
+        return fm_step_json
+
+    def validate_pre_experiment(self, fm_step_json: ForwardModelStepJSON) -> None:
+        import os
+        from pathlib import Path
+
+        from fmu.pem.pem_utilities import read_pem_config
+
+        model_dir_env = os.environ.get("PEM_MODEL_DIR")
+        if model_dir_env is None:
+            raise ValueError(
+                'environment variable "PEM_MODEL_DIR" must be set to '
+                "validate PEM model pre-experiment"
+            )
+        model_dir = Path(model_dir_env)
+
+        runpath_config_dir = Path(fm_step_json["argList"][3])
+        config_dir = (
+            model_dir
+            / "../.."
+            / runpath_config_dir.parent.name
+            / runpath_config_dir.name
+        ).resolve()
+        config_file = fm_step_json["argList"][5]
+        try:
+            os.chdir(model_dir)
+            _ = read_pem_config(config_dir / config_file)
+        except Exception as e:
+            raise ForwardModelStepValidationError(f"pem validation failed:\n {str(e)}")
+
+    @staticmethod
+    def documentation() -> ForwardModelStepDocumentation | None:
+        return ForwardModelStepDocumentation(
+            category="modelling.reservoir",
+            source_package="fmu.pem",
+            source_function_name="PetroElasticModel",
+            description="",
+            examples="""
+.. code-block:: console
+
+  FORWARD_MODEL PEM(<START_DIR>=../../rms/model, <CONFIG_DIR>=../../sim2seis/model, <CONFIG_FILE>=new_pem.yml)
+
+""",  # noqa: E501,
+        )

fmu/pem/hook_implementations/jobs.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import ert
+
+from fmu.pem.forward_models import PetroElasticModel
+
+PLUGIN_NAME = "pem"
+
+
+@ert.plugin(name=PLUGIN_NAME)
+def installable_workflow_jobs() -> dict[str, str]:
+    return {}
+
+
+@ert.plugin(name=PLUGIN_NAME)
+def installable_forward_model_steps() -> list[ert.ForwardModelStepPlugin]:
+    return [  # type: ignore
+        PetroElasticModel,
+    ]

fmu/pem/pem_functions/__init__.py

@@ -0,0 +1,17 @@
+from .density import estimate_bulk_density
+from .effective_pressure import estimate_pressure
+from .estimate_saturated_rock import estimate_saturated_rock
+from .fluid_properties import effective_fluid_properties
+from .mineral_properties import (
+    effective_mineral_properties,
+    estimate_effective_mineral_properties,
+)
+
+__all__ = [
+    "effective_fluid_properties",
+    "effective_mineral_properties",
+    "estimate_bulk_density",
+    "estimate_effective_mineral_properties",
+    "estimate_pressure",
+    "estimate_saturated_rock",
+]

fmu/pem/pem_functions/density.py

@@ -0,0 +1,55 @@
+from typing import List
+
+from rock_physics_open.equinor_utilities.std_functions import rho_b
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    SimInitProperties,
+    estimate_cement,
+)
+from fmu.pem.pem_utilities.rpm_models import PatchyCementRPM
+
+
+def estimate_bulk_density(
+    config: PemConfig,
+    init_prop: SimInitProperties,
+    fluid_props: List[EffectiveFluidProperties],
+    mineral_props: MatrixProperties,
+) -> List:
+    """
+    Estimate the bulk density per restart date.
+
+    Args:
+        config: Parameter settings.
+        init_prop: Constant properties, here using porosity.
+        fluid_props: List of EffectiveFluidProperties objects representing the effective
+            fluid properties per restart date.
+        mineral_props: EffectiveMineralProperties object representing the effective
+            properties.
+
+    Returns:
+        List of bulk densities per restart date.
+
+    Raises:
+        ValueError: If fluid_props is an empty list.
+    """
+    if config.rock_matrix.rpm == PatchyCementRPM:
+        # Get cement mineral properties
+        cement_mineral = config.rock_matrix.cement
+        mineral = config.rock_matrix.minerals[cement_mineral]
+        # Cement properties
+        cement_properties = estimate_cement(
+            mineral.bulk_modulus, mineral.shear_modulus, mineral.density, init_prop.poro
+        )
+        rel_frac_cem = (
+            config.rock_matrix.rpm.parameters.cement_fraction / init_prop.poro
+        )
+        rho_m = (
+            rel_frac_cem * cement_properties.dens
+            + (1 - rel_frac_cem) * mineral_props.dens
+        )
+    else:
+        rho_m = mineral_props.dens
+    return [rho_b(init_prop.poro, fluid.dens, rho_m) for fluid in fluid_props]

fmu/pem/pem_functions/effective_pressure.py

@@ -0,0 +1,168 @@
+from typing import List, Union
+
+import numpy as np
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    PressureProperties,
+    SimInitProperties,
+    SimRstProperties,
+    to_masked_array,
+)
+from fmu.pem.pem_utilities.enum_defs import OverburdenPressure
+
+from .density import estimate_bulk_density
+
+
+def estimate_pressure(
+    config: PemConfig,
+    sim_init: SimInitProperties,
+    sim_rst: List[SimRstProperties],
+    matrix_props: MatrixProperties,
+    fluid_props: list[EffectiveFluidProperties],
+) -> List[PressureProperties]:
+    """Estimate effective and overburden pressure.
+    Effective pressure is defined as overburden pressure minus formation (or pore)
+    pressure multiplied with the Biot factor
+
+    Args:
+        config: configuration parameters
+        sim_init: initial properties from simulation model
+        sim_rst: restart properties from the simulation model
+        matrix_props: rock properties
+        fluid_props: effective fluid properties
+
+    Returns:
+        effective pressure [bar], overburden_pressure [bar]
+
+    Raises:
+        ValueError: If sim_rst is an empty list.
+    """
+    # Effective pressure, get formation pressures and convert to Pa from bar
+    # Saturated rock bulk density bulk
+    bulk_density = estimate_bulk_density(config, sim_init, fluid_props, matrix_props)
+
+    ovb = config.pressure.overburden
+    if ovb.type == OverburdenPressure.CONSTANT:
+        eff_pres = [
+            estimate_effective_pressure(
+                formation_pressure=sim_date.pressure * 1.0e5,
+                bulk_density=dens,
+                reference_overburden_pressure=ovb.constant,
+            )
+            for (sim_date, dens) in zip(sim_rst, bulk_density)
+        ]
+    else:  # ovb.type == 'trend':
+        eff_pres = [
+            estimate_effective_pressure(
+                formation_pressure=sim_date.pressure * 1.0e5,
+                bulk_density=dens,
+                reference_overburden_pressure=overburden_pressure_from_trend(
+                    inter=ovb.trend.intercept,
+                    grad=ovb.trend.gradient,
+                    depth=sim_init.depth,
+                ),
+            )
+            for (sim_date, dens) in zip(sim_rst, bulk_density)
+        ]
+    # Sanity check on results - effective pressure should not be negative
+    for i, pres in enumerate(eff_pres):
+        if np.any(pres.effective_pressure < 0.0):
+            raise ValueError(
+                f"effective pressure calculation: formation pressure exceeds "
+                f"overburden pressure for date {config.global_params.seis_dates[i]}, \n"
+                f"minimum effective pressure is {np.min(pres.effective_pressure):.2f} "
+                f"bar, the number of cells with negative effective pressure is "
+                f"{np.sum(pres.effective_pressure < 0.0)}"
+            )
+    # Add effective pressure to RST properties
+    return eff_pres
+
+
+def estimate_effective_pressure(
+    formation_pressure: np.ma.MaskedArray,
+    bulk_density: np.ma.MaskedArray,
+    reference_overburden_pressure: Union[np.ma.MaskedArray, float],
+    biot_coeff: float = 1.0,
+) -> PressureProperties:
+    """Estimate effective pressure from reference overburden pressure, formation
+        pressure, depth and bulk density
+
+        Args:
+            formation_pressure: formation pressure [Pa]
+            bulk_density: bulk density [kg/m3]
+            reference_overburden_pressure: constant or one-layer array with reference
+            biot_coeff: Biot coefficient, in the range [0.0, 1.0] [unitless]
+    .mineral
+        Returns:
+            PressureProperties object with formation pressure [bar], effective pressure
+            [bar], overburden_pressure [bar]
+
+        Raises:
+            ValueError: If reference overburden pressure is not of type float or numpy
+            masked array, or if reference overburden pressure is not of the same
+            dimension as comparable grids, or if reference overburden pressure does
+            not have the same shape as comparable grids.
+    """
+    reference_overburden_pressure = _verify_ovb_press(
+        reference_overburden_pressure, bulk_density
+    )
+    effective_pressure = reference_overburden_pressure - biot_coeff * formation_pressure
+    return PressureProperties(
+        formation_pressure=formation_pressure * 1.0e-5,
+        effective_pressure=effective_pressure * 1.0e-5,
+        overburden_pressure=reference_overburden_pressure * 1.0e-5,
+    )
+
+
+def _verify_ovb_press(
+    ref_pres: Union[float, np.ma.MaskedArray], reference_cube: np.ma.MaskedArray
+) -> np.ma.MaskedArray:
+    if isinstance(ref_pres, float):
+        return to_masked_array(ref_pres, reference_cube)
+    if not isinstance(ref_pres, np.ma.MaskedArray):
+        raise ValueError(
+            f"{__file__}: Reference overburden pressure is not of type float or numpy "
+            "masked array"
+        )
+    if not ref_pres.ndim == reference_cube.ndim:
+        raise ValueError(
+            f"{__file__}: Reference overburden pressure is not of the same dimension "
+            "as comparable grids"
+        )
+    if not np.all(ref_pres.shape[0:-1] == reference_cube.shape[0:-1]):
+        raise ValueError(
+            f"{__file__}: Reference overburden pressure does not have the same shape "
+            "as comparable grids"
+        )
+    return ref_pres
+
+
+def overburden_pressure_from_trend(
+    inter: float, grad: float, depth: np.ma.MaskedArray
+) -> np.ma.MaskedArray:
+    """Calculate overburden pressure from depth trend for top of depth grid
+
+    Args:
+        inter: intercept in trend
+        grad: gradient in trend
+        depth: depth cube [m]
+
+    Returns:
+        overburden pressure [Pa]
+
+    Raises:
+        ValueError: If unable to calculate overburden pressure due to non-numeric
+        intercept or gradient.
+    """
+    try:
+        a = float(inter)
+        b = float(grad)
+        ovb_pres = a + b * depth
+    except ValueError as err:
+        raise ValueError(
+            f"{__file__}: unable to calculate overburden pressure:"
+        ) from err
+    return ovb_pres

fmu/pem/pem_functions/estimate_saturated_rock.py

@@ -0,0 +1,90 @@
+from typing import List
+
+from fmu.pem.pem_utilities import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PemConfig,
+    PressureProperties,
+    SaturatedRockProperties,
+    SimInitProperties,
+    estimate_cement,
+)
+from fmu.pem.pem_utilities.rpm_models import (
+    FriableRPM,
+    PatchyCementRPM,
+    RegressionModels,
+)
+
+from .regression_models import run_regression_models
+from .run_friable_model import run_friable
+from .run_patchy_cement_model import run_patchy_cement
+from .run_t_matrix_and_pressure import run_t_matrix_and_pressure_models
+
+
+def estimate_saturated_rock(
+    config: PemConfig,
+    sim_init: SimInitProperties,
+    eff_pres: list[PressureProperties],
+    matrix_props: MatrixProperties,
+    fluid_props: list[EffectiveFluidProperties],
+) -> List[SaturatedRockProperties]:
+    """Wrapper to call rock physics model
+
+    Args:
+        config: PEM configuration parameters
+        sim_init: initial properties from simulation model
+        eff_pres: restart properties from simulation model
+        matrix_props: rock properties (mineral and fluids)
+        fluid_props: effective fluid properties
+
+    Returns:
+        saturated rock properties per restart date
+    """
+    if isinstance(config.rock_matrix.rpm, PatchyCementRPM):
+        # Patchy cement model
+        cement = config.rock_matrix.minerals[config.rock_matrix.cement]
+        cement_properties = estimate_cement(
+            density=cement.density,
+            bulk_modulus=cement.bulk_modulus,
+            shear_modulus=cement.shear_modulus,
+            grid=sim_init.poro,
+        )
+        sat_rock_props = run_patchy_cement(
+            matrix_props,
+            fluid_props,
+            cement_properties,
+            sim_init.poro,
+            eff_pres,
+            config,
+        )
+    elif isinstance(config.rock_matrix.rpm, FriableRPM):
+        # Friable sandstone model
+        sat_rock_props = run_friable(
+            matrix_props,
+            fluid_props,
+            sim_init.poro,
+            eff_pres,
+            config,
+        )
+    elif isinstance(config.rock_matrix.rpm, RegressionModels):
+        # Regression models for dry rock properties, saturation by Gassmann
+        sat_rock_props = run_regression_models(
+            matrix_props,
+            fluid_props,
+            sim_init.poro,
+            eff_pres,
+            config,
+            vsh=sim_init.ntg_pem,
+        )
+    else:
+        # Using default values for T-Matrix parameter file and vp and vs pressure
+        # model files
+        sat_rock_props = run_t_matrix_and_pressure_models(
+            matrix_props,
+            fluid_props,
+            sim_init.poro,
+            sim_init.ntg_pem,
+            eff_pres,
+            config,
+        )
+    return sat_rock_props