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

fmu/pem/__main__.py

@@ -9,43 +9,59 @@ 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",
+        "--config-dir",
         type=Path,
         required=True,
         help="Path to config file (required)",
     )
     parser.add_argument(
         "-f",
-        "--configfile",
+        "--config-file",
         type=Path,
         required=True,
         help="Configuration yaml file name (required)",
     )
+    parser.add_argument(
+        "-g",
+        "--global-dir",
+        type=Path,
+        required=True,
+        help="Relative path to global config file (required)",
+    )
+    parser.add_argument(
+        "-o",
+        "--global-file",
+        type=Path,
+        required=True,
+        help="Global configuration yaml file name (required)",
+    )
+    parser.add_argument(
+        "-m",
+        "--model-dir",
+        type=Path,
+        required=False,
+        help="For ERT run: Absolute directory name for model file, pre-experiment. Not "
+        "needed for command line run",
+    )
     args = parser.parse_args()
-    cwd = args.startdir
-    if str(cwd).endswith("rms/model"):
+    cwd = args.config_dir.absolute()
+    if str(cwd).endswith("sim2seis/model"):
         run_folder = cwd
     else:
         try:
-            run_folder = cwd.joinpath("rms/model")
+            run_folder = cwd / "sim2seis" / "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}")
+            warn(f"PEM model should be run from the sim2seis/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,
+            config_dir=run_folder,
+            pem_config_file_name=args.config_file,
+            global_config_dir=args.global_dir,
+            global_config_file=args.global_file,
         )
 
 

fmu/pem/forward_models/pem_model.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import os
+from pathlib import Path
+
 from ert import (
     ForwardModelStepDocumentation,
     ForwardModelStepJSON,
@@ -7,6 +10,8 @@ from ert import (
     ForwardModelStepValidationError,
 )
 
+from fmu.pem.pem_utilities import read_pem_config
+
 
 class PetroElasticModel(ForwardModelStepPlugin):
     def __init__(self) -> None:
@@ -14,12 +19,16 @@ class PetroElasticModel(ForwardModelStepPlugin):
             name="PEM",
             command=[
                 "pem",
-                "--startdir",
-                "<START_DIR>",
-                "--configdir",
+                "--config-dir",
                 "<CONFIG_DIR>",
-                "--configfile",
+                "--config-file",
                 "<CONFIG_FILE>",
+                "--global-dir",
+                "<GLOBAL_DIR>",
+                "--global-file",
+                "<GLOBAL_FILE>",
+                "--model-dir",
+                "<MODEL_DIR>",
             ],
         )
 
@@ -29,30 +38,13 @@ class PetroElasticModel(ForwardModelStepPlugin):
         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]
+        # Parse YAML parameter file by pydantic pre-experiment to catch errors at an
+        # early stage
+        config_file = Path(fm_step_json["argList"][3])
+        model_dir = Path(fm_step_json["argList"][9])
         try:
             os.chdir(model_dir)
-            _ = read_pem_config(config_dir / config_file)
+            _ = read_pem_config(config_file)
         except Exception as e:
             raise ForwardModelStepValidationError(f"pem validation failed:\n {str(e)}")
 
@@ -66,7 +58,7 @@ class PetroElasticModel(ForwardModelStepPlugin):
             examples="""
 .. code-block:: console
 
-  FORWARD_MODEL PEM(<START_DIR>=../../rms/model, <CONFIG_DIR>=../../sim2seis/model, <CONFIG_FILE>=new_pem.yml)
+  FORWARD_MODEL PEM(<CONFIG_DIR>=../../sim2seis/model, <CONFIG_FILE>=new_pem.yml, <GLOBAL_DiR>=../../fmuconfig/output, <GLOBAL_FILE>=global_variables.yml, <MODEL_DIR>=/my_fmu_structure/sim2seis/model)
 
 """,  # noqa: E501,
         )

fmu/pem/pem_functions/__init__.py

@@ -1,14 +1,14 @@
 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 .fluid_properties import effective_fluid_properties_zoned
 from .mineral_properties import (
     effective_mineral_properties,
     estimate_effective_mineral_properties,
 )
 
 __all__ = [
-    "effective_fluid_properties",
+    "effective_fluid_properties_zoned",
     "effective_mineral_properties",
     "estimate_bulk_density",
     "estimate_effective_mineral_properties",

fmu/pem/pem_functions/density.py

@@ -1,55 +1,49 @@
-from typing import List
-
+from numpy.ma import MaskedArray
 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:
-    """
+    porosity: MaskedArray,
+    fluid_density: list[MaskedArray],
+    mineral_density: MaskedArray,
+    *,
+    patchy_cement: bool = False,
+    cement_fraction: float | None = None,
+    cement_density: float | None = None,
+) -> list[MaskedArray]:
+    r"""
     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.
+        porosity: Initial simulation  porosity.
+        fluid_density: Effective fluid density per date.
+        mineral_density: Effective mineral (matrix) density.
+        patchy_cement: Enable patchy_cement mixing.
+        cement_fraction: Cement volume fraction within pore space.
+        cement_density: Cement density.
 
     Returns:
-        List of bulk densities per restart date.
+        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]
+    if not fluid_density:
+        raise ValueError("Fluid properties cannot be an empty list.")
+
+    if patchy_cement:
+        if any(v is None for v in (cement_fraction, cement_density)):
+            raise ValueError(
+                "cement_fraction and cement_props must be provided when "
+                "patchy_cement is True."
+            )
         # 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
-        )
+        rel_cement_fraction = cement_fraction / porosity
         rho_m = (
-            rel_frac_cem * cement_properties.dens
-            + (1 - rel_frac_cem) * mineral_props.dens
+            rel_cement_fraction * cement_density
+            + (1 - rel_cement_fraction) * mineral_density
         )
     else:
-        rho_m = mineral_props.dens
-    return [rho_b(init_prop.poro, fluid.dens, rho_m) for fluid in fluid_props]
+        rho_m = mineral_density
+
+    return [rho_b(porosity, rho_fl, rho_m) for rho_fl in fluid_density]  # type: ignore

fmu/pem/pem_functions/effective_pressure.py

@@ -1,90 +1,195 @@
-from typing import List, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
 from fmu.pem.pem_utilities import (
     EffectiveFluidProperties,
-    MatrixProperties,
-    PemConfig,
+    EffectiveMineralProperties,
     PressureProperties,
     SimInitProperties,
     SimRstProperties,
     to_masked_array,
 )
-from fmu.pem.pem_utilities.enum_defs import OverburdenPressure
+from fmu.pem.pem_utilities.enum_defs import (
+    OverburdenPressureTypes,
+    RPMType,
+)
+from fmu.pem.pem_utilities.fipnum_pvtnum_utilities import (
+    input_num_string_to_list,
+    validate_zone_coverage,
+)
+from fmu.pem.pem_utilities.pem_config_validation import (
+    OverburdenPressureConstant,
+    OverburdenPressureTrend,
+)
 
 from .density import estimate_bulk_density
 
+if TYPE_CHECKING:
+    from fmu.pem.pem_utilities import RockMatrixProperties
+
 
 def estimate_pressure(
-    config: PemConfig,
+    rock_matrix: "RockMatrixProperties",
+    overburden_pressure: list[OverburdenPressureTrend | OverburdenPressureConstant],
     sim_init: SimInitProperties,
-    sim_rst: List[SimRstProperties],
-    matrix_props: MatrixProperties,
+    sim_rst: list[SimRstProperties],
+    matrix_props: EffectiveMineralProperties,
     fluid_props: list[EffectiveFluidProperties],
-) -> List[PressureProperties]:
-    """Estimate effective and overburden pressure.
+    sim_dates: list[str],
+    fipnum: np.ma.MaskedArray,
+) -> list[PressureProperties]:
+    """Estimate effective and overburden pressure with per-zone overburden pressure
+    definitions.
+
     Effective pressure is defined as overburden pressure minus formation (or pore)
-    pressure multiplied with the Biot factor
+    pressure multiplied with the Biot factor. Overburden pressure is zone-aware
+    (defined per FIPNUM group) but constant in time, while effective pressure
+    varies with time as formation pressure changes.
+
+    This function now supports zone-based rock physics models. Each zone can have
+    its own model type (e.g., Patchy Cement, Friable), which affects bulk density
+    calculation for overburden pressure estimation.
 
     Args:
-        config: configuration parameters
+        rock_matrix: rock matrix properties with zone-specific model definitions
+        overburden_pressure: list of trend or constant value for overburden pressure
+            per FIPNUM zone group
         sim_init: initial properties from simulation model
-        sim_rst: restart properties from the simulation model
-        matrix_props: rock properties
-        fluid_props: effective fluid properties
+        sim_rst: restart properties from the simulation model (time-dependent)
+        matrix_props: effective mineral properties
+        fluid_props: effective fluid properties (time-dependent)
+        sim_dates: list of dates for simulation
+        fipnum: grid parameter with zone/region information
 
     Returns:
-        effective pressure [bar], overburden_pressure [bar]
+        List of PressureProperties for each time step containing effective pressure
+        [bar], formation pressure [bar], and overburden_pressure [bar]
 
     Raises:
-        ValueError: If sim_rst is an empty list.
+        ValueError: If FIPNUM zone definitions are invalid or if effective pressure
+            is negative for any cells.
     """
-    # 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,
+    # Validate zone coverage
+    fipnum_strings: list[str] = [str(zone.fipnum) for zone in overburden_pressure]
+    validate_zone_coverage(fipnum_strings, fipnum, zone_name="FIPNUM")
+
+    # Get FIPNUM grid data and mask
+    fipnum_data = fipnum.data
+    fipnum_mask = (
+        fipnum.mask
+        if hasattr(fipnum, "mask")
+        else np.zeros_like(fipnum_data, dtype=bool)
+    )
+
+    # Get actual FIPNUM values present in grid for use with input_num_string_to_list
+    actual_fipnum_values = list(np.unique(fipnum_data[~fipnum_mask]).astype(int))
+
+    # Calculate bulk density for all time steps (needed for overburden pressure
+    # calculation)
+    # Bulk density calculation needs to be zone-aware for patchy cement models
+    fl_density = [fluid.density for fluid in fluid_props]
+
+    # Check if any zone uses patchy cement model and needs special handling
+    bulk_density = []
+    for fl_dens in fl_density:
+        bulk_dens_grid = np.ma.masked_array(
+            np.zeros(sim_init.poro.shape, dtype=float), mask=fipnum_mask
+        )
+
+        # Calculate bulk density per zone based on zone-specific model
+        for zone_region in rock_matrix.zone_regions:
+            # Get all FIPNUM values for this zone using input_num_string_to_list
+            fipnum_values = input_num_string_to_list(
+                zone_region.fipnum, actual_fipnum_values
+            )
+
+            # Build combined mask for all FIPNUMs in this zone using vectorized
+            # operation
+            zone_mask = np.isin(fipnum_data, fipnum_values) & ~fipnum_mask
+
+            # Check if this zone uses patchy cement model
+            is_patchy_cement = zone_region.model.model_name == RPMType.PATCHY_CEMENT
+
+            if is_patchy_cement:
+                # Get cement fraction and density for patchy cement model
+                cement_fraction = zone_region.model.parameters.cement_fraction
+                cement_density = rock_matrix.minerals[rock_matrix.cement].density
+            else:
+                cement_fraction = None
+                cement_density = None
+
+            # Calculate bulk density for this zone
+            zone_bulk_density = estimate_bulk_density(
+                porosity=np.ma.masked_where(~zone_mask, sim_init.poro),
+                fluid_density=[np.ma.masked_where(~zone_mask, fl_dens)],
+                mineral_density=np.ma.masked_where(~zone_mask, matrix_props.density),
+                patchy_cement=is_patchy_cement,
+                cement_fraction=cement_fraction,
+                cement_density=cement_density,
             )
-            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,
-                ),
+
+            # Merge zone bulk density into full grid
+            bulk_dens_grid[zone_mask] = zone_bulk_density[0][zone_mask]
+
+            bulk_density.append(bulk_dens_grid)
+
+    # Calculate overburden pressure per zone (time-independent)
+    # Initialize overburden pressure grid
+    overburden_pressure_grid = np.ma.masked_array(
+        np.full(sim_init.depth.shape, np.nan, dtype=float), mask=fipnum_mask
+    )
+
+    for zone in overburden_pressure:
+        # Get all FIPNUM values for this zone using input_num_string_to_list
+        fipnum_values = input_num_string_to_list(zone.fipnum, actual_fipnum_values)
+
+        # Build combined mask for all FIPNUMs in this zone using vectorized operation
+        mask_cells = np.isin(fipnum_data, fipnum_values) & ~fipnum_mask
+
+        if zone.type == OverburdenPressureTypes.CONSTANT:
+            # Constant overburden pressure for this zone
+            overburden_pressure_grid[mask_cells] = zone.value
+        else:  # zone.type == OverburdenPressureTypes.TREND
+            # Calculate overburden pressure from trend for this zone (already in Pa)
+            zone_ovb_pres = overburden_pressure_from_trend(
+                inter=zone.intercept,
+                grad=zone.gradient,
+                depth=sim_init.depth,
             )
-            for (sim_date, dens) in zip(sim_rst, bulk_density)
-        ]
+            overburden_pressure_grid[mask_cells] = zone_ovb_pres[mask_cells]
+
+    # Calculate effective pressure for each time step
+    # Formation pressure changes with time, but overburden pressure is constant
+    eff_pres = [
+        estimate_effective_pressure(
+            formation_pressure=sim_date.pressure,
+            bulk_density=dens,
+            reference_overburden_pressure=overburden_pressure_grid,
+        )
+        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"overburden pressure for date {sim_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],
+    reference_overburden_pressure: np.ma.MaskedArray | float,
     biot_coeff: float = 1.0,
 ) -> PressureProperties:
     """Estimate effective pressure from reference overburden pressure, formation
@@ -111,14 +216,14 @@ def estimate_effective_pressure(
     )
     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,
+        formation_pressure=formation_pressure,
+        effective_pressure=effective_pressure,
+        overburden_pressure=reference_overburden_pressure,
     )
 
 
 def _verify_ovb_press(
-    ref_pres: Union[float, np.ma.MaskedArray], reference_cube: np.ma.MaskedArray
+    ref_pres: 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)