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

fmu/pem/pem_utilities/enum_defs.py

@@ -3,6 +3,7 @@ Define enumerated strings
 """
 
 from enum import Enum
+from typing import Literal
 
 
 class OverburdenPressureTypes(str, Enum):
@@ -49,22 +50,78 @@ class RPMType(str, Enum):
     REGRESSION = "regression"
 
 
-class VolumeFractions(str, Enum):
-    NTG_SIM = "ntg_sim"
-    VOL_FRAC = "fraction_files"
-
-
 class GasModels(str, Enum):
     GLOBAL = "Global"
     LIGHT = "Light"
     HC2016 = "HC2016"
 
 
-class CoordinationNumberFunction(str, Enum):
-    PORBASED = "PorBased"
-    CONSTANT = "ConstVal"
+# class CoordinationNumberFunction(str, Enum):
+#     PORBASED = "PorBased"
+#     CONSTANT = "ConstVal"
+CoordinationNumberFunction = Literal["PorBased", "ConstVal"]
 
 
 class TemperatureMethod(str, Enum):
     CONSTANT = "constant"
     FROMSIM = "from_sim"
+
+
+class DifferenceMethod(str, Enum):
+    DIFF = "diff"
+    DIFFPERCENT = "diffpercent"
+    RATIO = "ratio"
+
+
+class DifferenceAttribute(str, Enum):
+    AI = "ai"
+    VPVS = "vpvs"
+    SI = "si"
+    VP = "vp"
+    VS = "vs"
+    DENS = "dens"
+    TWT = "twt"
+    SGAS = "sgas"
+    SWAT = "swat"
+    SOIL = "soil"
+    RS = "rs"
+    RV = "rv"
+    PRESSURE = "pressure"
+    SALT = "salt"
+    TEMP = "temp"
+    TWTPP = "twtpp"
+    TWTSS = "twtss"
+    TWTPS = "twtps"
+    FORMATION_PRESSURE = "formation_pressure"
+    EFFECTIVE_PRESSURE = "effective_pressure"
+    OVERBURDEN_PRESSURE = "overburden_pressure"
+
+
+class RegressionPressureModelTypes(str, Enum):
+    EXPONENTIAL = "exponential"
+    POLYNOMIAL = "polynomial"
+
+
+class PhysicsPressureModelTypes(str, Enum):
+    FRIABLE = "friable"
+    PATCHY_CEMENT = "patchy_cement"
+
+
+class RegressionPressureParameterTypes(str, Enum):
+    VP_VS = "vp_vs"
+    K_MU = "k_mu"
+
+
+class ParameterTypes(str, Enum):
+    VP = "vp"
+    VS = "vs"
+    K = "k"
+    MU = "mu"
+    RHO = "rho"
+    POROSITY = "poro"
+
+
+class Sim2SeisRequiredParams(str, Enum):
+    VP = "vp"
+    VS = "vs"
+    DENSITY = "density"

fmu/pem/pem_utilities/export_routines.py

@@ -1,42 +1,57 @@
 import warnings
 from dataclasses import asdict
 from pathlib import Path
-from typing import List, Union
 
+import numpy as np
 import xtgeo
 
+from .enum_defs import Sim2SeisRequiredParams
 from .pem_class_definitions import (
+    DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
+    EffectiveMineralProperties,
     PressureProperties,
     SaturatedRockProperties,
 )
-from .pem_config_validation import FromGlobal, PemConfig
 from .utils import _verify_export_inputs, restore_dir
 
 
 def save_results(
-    start_dir: Path,
+    config_dir: Path,
     run_from_rms_flag: bool,
-    config_settings: PemConfig,
     rms_project: object,
     sim_grid: xtgeo.grid3d.Grid,
+    grid_name: str,
+    seis_dates: list[str],
+    save_to_rms: bool,
+    save_to_disk: bool,
+    save_intermediate: bool,
+    mandatory_path: Path,
+    pem_output_path: Path,
     eff_pres_props: list[PressureProperties],
     sat_rock_props: list[SaturatedRockProperties],
-    difference_props: List[dict],
-    difference_date_strs: List[str],
-    matrix_props: MatrixProperties,
+    difference_props: list[dict],
+    difference_date_strs: list[str],
+    matrix_props: EffectiveMineralProperties,
     fluid_props: list[EffectiveFluidProperties],
+    bubble_point_grids: list[dict[str, np.ma.MaskedArray]],
+    dry_rock_props: list[DryRockProperties],
 ) -> None:
     """Saves all intermediate and final results according to the settings in the PEM
     and global config files
 
     Args:
-        start_dir: initial directory setting
+        config_dir: initial directory setting
         run_from_rms_flag: call to PEM from RMS
-        config_settings: PEM and global settings
         rms_project: RMS project
         sim_grid: grid definition
+        grid_name: stem of output grid name
+        seis_dates: list of dates for simulation runs
+        save_to_rms: save results to RMS project
+        save_to_disk: save non-mandatory results to disk
+        save_intermediate: save intermediate calculations to disk
+        mandatory_path: path for mandatory output
+        pem_output_path: path for non-mandatory PEM output
         eff_pres_props: effective, overburden and formation pressure per time step
         sat_rock_props: elastic properties of saturated rock
         difference_props: differences in elastic properties between selected restart
@@ -49,61 +64,51 @@ def save_results(
         None, warning or KeyError
     """
     # Saving results:
-    # 1. Mandatory part: Save Vp, Vs, Density to disk for seismic forward modelling.
-    # Use FMU standard term "DENS" for density
-
-    # mypy needs an assert in the same function as the usage - it did not pick up a
-    # verification in a separate function without it, mypy reports errors, assuming
-    # global_params is None
 
-    assert isinstance(config_settings.global_params, FromGlobal)
-
-    pem_output_path = start_dir.joinpath(
-        config_settings.paths.rel_path_mandatory_output
-    )
-    output_path = start_dir.joinpath(config_settings.paths.rel_path_output)
+    # 1. Mandatory part: Save Vp, Vs, Density to disk for seismic forward modelling.
+    full_mandatory_path = config_dir / mandatory_path
+    full_output_path = config_dir / pem_output_path
     output_set = [
         {
             k: v
-            for (k, v) in asdict(sat_prop).items()  # type: ignore
-            if k.upper() in ["VP", "VS", "DENS"]
+            for (k, v) in asdict(sat_prop).items()
+            if k in list(Sim2SeisRequiredParams)
         }
         for sat_prop in sat_rock_props
     ]
     export_results_disk(
-        output_set,
-        sim_grid,
-        config_settings.global_params.grid_model,
-        pem_output_path,
-        time_steps=config_settings.global_params.seis_dates,
+        result_props=output_set,
+        grid=sim_grid,
+        grid_name=grid_name,
+        results_dir=full_mandatory_path,
+        time_steps=seis_dates,
         export_format="grdecl",
     )
 
     # 2. Save results to rms and/or disk according to config file
 
     # create list of dict from list of pressure and saturated rock objects
-    eff_pres_dict_list = [asdict(obj) for obj in eff_pres_props]  # type: ignore  # NB: this is a pycharm bug to be removed
-    sat_prop_dict_list = [asdict(obj) for obj in sat_rock_props]  # type: ignore
+    eff_pres_dict_list = [asdict(obj) for obj in eff_pres_props]
+    sat_prop_dict_list = [asdict(obj) for obj in sat_rock_props]
 
     try:
-        if config_settings.results.save_results_to_rms and run_from_rms_flag:
-            grid_model = config_settings.global_params.grid_model
+        if save_to_rms and run_from_rms_flag:
             # Time dependent absolute properties
             for props in [eff_pres_dict_list, sat_prop_dict_list]:
                 prop_dict = list(props)
                 export_results_roxar(
-                    rms_project,
-                    prop_dict,
-                    sim_grid,
-                    grid_model,
-                    time_steps=config_settings.global_params.seis_dates,
+                    prj=rms_project,
+                    result_props=prop_dict,
+                    grid=sim_grid,
+                    rms_grid_name=grid_name,
+                    time_steps=seis_dates,
                 )
             # Difference properties
             export_results_roxar(
-                rms_project,
-                difference_props,
-                sim_grid,
-                grid_model,
+                prj=rms_project,
+                result_props=difference_props,
+                grid=sim_grid,
+                rms_grid_name=grid_name,
                 time_steps=difference_date_strs,
             )
     except KeyError:  # warn user that results are not saved
@@ -112,21 +117,21 @@ def save_results(
             f"config file"
         )
     try:
-        if config_settings.results.save_results_to_disk:
+        if save_to_disk:
             for props in [eff_pres_dict_list, sat_prop_dict_list]:
                 prop_dict = list(props)
                 export_results_disk(
-                    prop_dict,
-                    sim_grid,
-                    sim_grid.name,
-                    output_path,
-                    time_steps=config_settings.global_params.seis_dates,
+                    result_props=prop_dict,
+                    grid=sim_grid,
+                    grid_name=sim_grid.name,
+                    results_dir=full_output_path,
+                    time_steps=seis_dates,
                 )
             export_results_disk(
-                difference_props,
-                sim_grid,
-                config_settings.global_params.grid_model,
-                output_path,
+                result_props=difference_props,
+                grid=sim_grid,
+                grid_name=grid_name,
+                results_dir=full_output_path,
                 time_steps=difference_date_strs,
             )
     except KeyError:  # warn user that results are not saved
@@ -137,22 +142,29 @@ def save_results(
 
     # 3. Save intermediate results only if specified in the config file
     try:
-        if config_settings.results.save_intermediate_results:
-            export_results_disk(
-                [asdict(fl_props) for fl_props in fluid_props],  # type: ignore
-                sim_grid,
-                config_settings.global_params.grid_model,
-                output_path,
-                time_steps=config_settings.global_params.seis_dates,
-                name_suffix="_FLUID",
-            )
-            export_results_disk(
-                asdict(matrix_props),  # type: ignore
-                sim_grid,
-                config_settings.global_params.grid_model,
-                output_path,
-                name_suffix="_MINERAL",
-            )
+        if save_intermediate:
+            export_dicts = [
+                [asdict(fl_props) for fl_props in fluid_props],
+                asdict(matrix_props),
+                bubble_point_grids,
+                [asdict(dry_props) for dry_props in dry_rock_props],
+            ]
+            suffices = [
+                "_FLUID",
+                "_MINERAL",
+                "",
+                "_DRY_ROCK",
+            ]
+            dates = [seis_dates, None, seis_dates, seis_dates]
+            for props, date_info, suffix in zip(export_dicts, dates, suffices):
+                export_results_disk(
+                    result_props=props,
+                    grid=sim_grid,
+                    grid_name=grid_name,
+                    results_dir=full_output_path,
+                    time_steps=date_info,
+                    name_suffix=suffix,
+                )
     except KeyError:
         # just skip silently if save_intermediate_results is not present in the
         # pem_config
@@ -162,10 +174,10 @@ def save_results(
 
 def export_results_roxar(
     prj: object,
-    result_props: Union[List[dict], dict],
+    result_props: list[dict] | dict,
     grid: xtgeo.grid3d.Grid,
     rms_grid_name: str,
-    time_steps: Union[List[str], None] = None,
+    time_steps: list[str] | None = None,
     name_suffix: str = "",
     force_write_grid: bool = False,
 ) -> None:
@@ -218,11 +230,11 @@ def _verify_gridmodel(prj: object, rms_grid_model_name: str, grid: xtgeo.grid3d.
 
 
 def export_results_disk(
-    result_props: Union[List[dict], dict],
+    result_props: list[dict] | dict,
     grid: xtgeo.grid3d.Grid,
     grid_name: str,
     results_dir: Path,
-    time_steps: Union[List[str], None] = None,
+    time_steps: list[str] | None = None,
     name_suffix: str = "",
     export_format: str = "roff",
 ) -> None:

fmu/pem/pem_utilities/fipnum_pvtnum_utilities.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import numpy as np
+
+
+def input_num_string_to_list(
+    input_string: str,
+    num_array: list[int],
+) -> list[int]:
+    """Input is a string of comma-separated ranges like
+    10-15, 20-25 and outputs the expanded verbose list of individual integers.
+    """
+
+    parts = [part.strip() for part in input_string.split(",")]
+
+    integers = []
+
+    for part in parts:
+        if "-" in part:
+            [start, end] = [int(integer) for integer in part.split("-")]
+            integers += list(range(start, end + 1))
+        elif "*" in part:
+            return num_array
+        else:
+            try:
+                integers.append(int(part))
+            except ValueError as e:
+                raise ValueError(f"unable to convert string '{part}' to integers: {e}")
+
+    unique_integer_list = list(set(integers))
+    unique_integer_list.sort()
+
+    return unique_integer_list
+
+
+def num_boolean_array(
+    input_string: str,
+    num_array: list[int],
+) -> np.ndarray:
+    """Returns a boolean array where a given element is True if the corresponding
+    element in num_array (representing PVTNUM/FIPNUM) is part of the input_string
+    definition, which is of format e.g. "10-20, 25"
+    """
+
+    if input_string.strip() == "*":
+        return np.ones(np.shape(num_array), dtype=bool)
+
+    _validate_input_strings(
+        [
+            input_string,
+        ],
+        num_array,
+    )
+
+    return np.isin(num_array, input_num_string_to_list(input_string, num_array))
+
+
+def missing_num_areas(
+    input_strings: list[str],
+    num_array: list[int],
+) -> list[int]:
+    """Returns a list of all FIPNUM/PVTNUM integers not covered by the user input.
+    If all integers are covered, the return value is an empty list. This function
+    can be used to get a list of FIPNUM or PVTNUM areas the user has not given
+    a value for.
+    """
+    _validate_input_strings(input_strings, num_array)
+
+    if any(input_string.strip() == "*" for input_string in input_strings):
+        return []
+
+    unique_integers_grid = set(num_array)
+
+    unique_integers_input_config = {
+        num
+        for input_string in input_strings
+        for num in input_num_string_to_list(input_string, num_array)
+    }
+
+    missing_areas = list(unique_integers_grid - unique_integers_input_config)
+    missing_areas.sort()
+
+    return missing_areas
+
+
+def detect_overlaps(
+    input_strings: list[str],
+    num_array: list[int],
+) -> bool:
+    """If there are any overlapping groups in the input strings, returns True."""
+    _validate_input_strings(input_strings, num_array)
+
+    def _map_values(inp_array: list[int], all_num_array: list[int]) -> list[int]:
+        return [all_num_array.index(num) for num in inp_array if num in all_num_array]
+
+    is_already_taken = np.zeros_like(num_array, dtype=bool)
+    for string in input_strings:
+        string_nums = input_num_string_to_list(string, num_array)
+        position_list = _map_values(string_nums, num_array)
+        if np.any(is_already_taken[position_list]):
+            return True
+        is_already_taken[position_list] = True
+    return False
+
+
+def _validate_input_strings(
+    input_strings: list[str],
+    num_array: list[int],
+) -> None:
+    """Make sure that there are no numbers in the input strings that are not part
+    of num_array, but allow ranges to cover missing numbers in num_array"""
+    num_set = set(num_array)
+    min_num = min(num_array)
+    max_num = max(num_array)
+
+    for input_string in input_strings:
+        parts = [part.strip() for part in input_string.split(",")]
+
+        for part in parts:
+            if "*" in part:
+                continue
+            if "-" in part:
+                # Ranges are allowed to span missing numbers in num_array
+                # But range endpoints must be within min/max bounds
+                try:
+                    start, end = [int(integer) for integer in part.split("-")]
+                    if start > end:
+                        raise ValueError(f"Invalid range '{part}': start > end")
+                    if start < min_num or start > max_num:
+                        raise ValueError(
+                            f"Range start {start} in '{part}' is outside "
+                            f"num_array bounds [{min_num}, {max_num}]"
+                        )
+                    if end > max_num:
+                        raise ValueError(
+                            f"Range end {end} in '{part}' is outside "
+                            f"num_array bounds [{min_num}, {max_num}]"
+                        )
+                except ValueError as e:
+                    if "outside" in str(e) or "Invalid range" in str(e):
+                        raise
+                    raise ValueError(f"Invalid range format '{part}': {e}")
+            else:
+                # Individual numbers must exist in num_array
+                try:
+                    num = int(part)
+                    if num not in num_set:
+                        raise ValueError(
+                            f"Individual number {num} from input '{input_string}' "
+                            f"not found in num_array"
+                        )
+                except ValueError as e:
+                    if "not found in num_array" in str(e):
+                        raise
+                    raise ValueError(f"Unable to parse '{part}' as integer: {e}")
+
+
+def validate_zone_coverage(
+    zone_strings: list[str],
+    grid_values: np.ma.MaskedArray,
+    zone_name: str = "zone",
+) -> None:
+    """
+    Validate that all grid values have corresponding zone definitions.
+
+    Enforces:
+    - Single wildcard '*' cannot appear with other groups
+    - No overlaps among explicit definitions
+    - All grid values covered by definitions
+
+    Args:
+        zone_strings: List of zone definition strings (e.g., ["*"] or ["1-5", "6-10"])
+        grid_values: Masked array of zone integers from simulator grid
+        zone_name: Name of zone type for error messages (e.g., "PVTNUM", "FIPNUM")
+
+    Raises:
+        ValueError: If wildcard misused, overlaps detected, or grid values lack
+        definitions
+    """
+    # Extract unique values from grid
+    grid_data = grid_values.data
+    grid_mask = (
+        grid_values.mask
+        if hasattr(grid_values, "mask")
+        else np.zeros_like(grid_data, dtype=bool)
+    )
+    actual_values = set(np.unique(grid_data[~grid_mask]).astype(int))
+
+    if not actual_values:
+        raise ValueError(f"No valid {zone_name} values found in grid")
+
+    # Check for wildcard-only definition
+    if "*" in zone_strings:
+        if len(zone_strings) > 1:
+            raise ValueError(
+                f"Wildcard '*' cannot be combined with explicit {zone_name} "
+                "definitions. Either use '*' alone or list all zones explicitly."
+            )
+        return  # Wildcard covers everything
+
+    # Check for overlaps in explicit definitions
+    max_val = max(actual_values)
+    tmp_array = list(range(1, max_val + 1))
+    if detect_overlaps(zone_strings, tmp_array):
+        raise ValueError(f"Overlapping {zone_name} definitions found: {zone_strings}")
+
+    # Check coverage: all grid values must have definitions
+    defined_values = set()
+    for zone_str in zone_strings:
+        defined_values.update(input_num_string_to_list(zone_str, tmp_array))
+
+    missing = actual_values - defined_values
+    if missing:
+        raise ValueError(
+            f"{zone_name} values {sorted(missing)} are present in grid but have no "
+            f"zone definition. Add explicit definitions for these values."
+        )