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

fmu/pem/pem_utilities/import_config.py

@@ -9,66 +9,92 @@ from .pem_config_validation import PemConfig
 from .utils import restore_dir
 
 
-def get_global_params_and_dates(root_dir: Path, conf_path: Path) -> dict:
+def find_key_first(d: dict, key: str) -> str | None:
+    """Recursively search for the first occurrence of a key in nested dicts.
+
+    The search now prioritizes keys at the current dictionary level before
+    descending into nested dictionaries, ensuring top-level occurrences win when
+    duplicates exist deeper in the structure.
+
+    Args:
+        d: A potentially nested mapping structure where values may themselves be
+            dictionaries. Typically a ``dict`` originating from parsed YAML/JSON.
+        key: The key to search for in ``d`` and any nested dictionaries.
+
+    Returns:
+        The value associated with the first occurrence of ``key`` encountered during
+        the depth-first search, or ``None`` if the key is not present.
+
+    Example:
+        >>> data = {"a": 1, "b": {"target": 2, "c": {"target": 3}}}
+        >>> find_key_first(data, "target")
+        2
+    """
+    if not isinstance(d, dict):
+        return None
+    if key in d:
+        return d[key]
+    for v in d.values():
+        if isinstance(v, dict):
+            result = find_key_first(v, key)
+            if result is not None:
+                return result
+    return None
+
+
+def get_global_params_and_dates(
+    global_config_dir: Path,
+    global_conf_file: Path,
+    mod_prefix: str | None = None,
+    obs_prefix: str | None = None,
+) -> dict:
     """Read global configuration parameters, simulation model dates and seismic dates
     for difference calculation
 
     Args:
-        root_dir: start dir for PEM script run
-        conf_path: path to global variables configuration file
+        global_config_dir: directory path for the global config file
+        global_conf_file: name of the global config file
 
     Returns:
         global parameter configuration dict, list of strings for simulation dates,
         list of tuples with
                 strings of dates to calculate difference properties
     """
-    # prediction_mode is set to empty string if HIST else to PRED. Normally set in
-    # env variable
-    env_flowsim = os.getenv("FLOWSIM_IS_PREDICTION", default=False)
-    if env_flowsim:
-        conf_file = conf_path.joinpath("global_variables_pred.yml")
-        date_str = "SEISMIC_PRED_DATES"
-        diff_str = "SEISMIC_PRED_DIFFDATES"
-    else:
-        conf_file = conf_path.joinpath("global_variables.yml")
-        date_str = "SEISMIC_HIST_DATES"
-        diff_str = "SEISMIC_HIST_DIFFDATES"
-    with restore_dir(root_dir):
-        global_config_par = yaml_load(str(conf_file))
-        seismic_dates = [
-            str(sdate).replace("-", "")
-            for sdate in global_config_par["global"]["dates"][date_str]
-        ]
-        diff_dates = [
-            [str(sdate).replace("-", "") for sdate in datepairs]
-            for datepairs in global_config_par["global"]["dates"][diff_str]
-        ]
-        # Grid model name can be under different top dicts - search for it. If more
-        # than one is found, and they are not equal - raise an error
-        found_grid_name = False
-        for key in global_config_par:
-            try:
-                if not found_grid_name:
-                    grid_model_name = global_config_par[key]["ECLGRIDNAME_PEM"]
-                    found_grid_name = True
-                else:
-                    if not grid_model_name == global_config_par[key]["ECLGRIDNAME_PEM"]:
-                        raise ValueError(
-                            f"{__file__}: inconsistent names for "
-                            f"ECLGRIDNAME_PEM in global config file"
-                        )
-            except KeyError:
-                pass
-        if not found_grid_name:
-            raise ValueError(
-                f"{__file__}: no value for ECLGRIDNAME_PEM in global config file"
-            )
-        return {
-            "grid_model": grid_model_name,
-            "seis_dates": seismic_dates,
-            "diff_dates": diff_dates,
-            "global_config": global_config_par,
-        }
+    global_config_par = yaml_load(
+        str(global_config_dir / global_conf_file),
+    )
+    grid_model_name = find_key_first(global_config_par["global"], "ECLGRIDNAME_PEM")
+    if grid_model_name is None:
+        raise ValueError(
+            f"{__file__}: no value for ECLGRIDNAME_PEM in global config file"
+        )
+    # Find the correct seismic dates references
+    dates_config = global_config_par["global"]["dates"]
+    return_dict = {
+        "global_config": global_config_par,
+        "grid_model": grid_model_name,
+        "seismic": global_config_par["global"]["seismic"],
+    }
+    if mod_prefix:
+        return_dict.update(
+            {
+                "mod_dates": dates_config.get(f"SEISMIC_{mod_prefix}_DATES", None),
+                "mod_diffdates": dates_config.get(
+                    f"SEISMIC_{mod_prefix}_DIFFDATES", None
+                ),
+            }
+        )
+    if obs_prefix:
+        return_dict.update(
+            {
+                "obs_dates": dates_config.get(f"SEISMIC_{obs_prefix}_DATES", None),
+                "obs_diffdates": dates_config.get(
+                    f"SEISMIC_{obs_prefix}_DIFFDATES", None
+                ),
+            }
+        )
+
+    return return_dict
 
 
 def read_pem_config(yaml_file: Path) -> PemConfig:

fmu/pem/pem_utilities/import_routines.py

@@ -1,61 +1,47 @@
 from pathlib import Path
-from typing import List, Tuple
 
-import numpy as np
 import xtgeo
 
 from .pem_class_definitions import SimInitProperties, SimRstProperties
-from .pem_config_validation import PemConfig
-from .utils import restore_dir
-
-
-def read_geogrid(root_dir: Path, config: PemConfig) -> dict:
-    """Not in use? Read porosity from geo-grid
-
-    Args:
-        root_dir: start dir for PEM script run
-        config: PEM specific parameters
-
-    Returns:
-        Dict object with porosity
-    """
-    with restore_dir(root_dir.joinpath(config.paths.rel_path_geogrid)):
-        return {"poro": xtgeo.gridproperty_from_file("geogrid--phit.roff").values}
+from .utils import bar_to_pa, restore_dir
 
 
 def read_init_properties(
-    property_file: Path, sim_grid: xtgeo.Grid
+    property_file: Path,
+    sim_grid: xtgeo.Grid,
+    fipnum_param: str,
 ) -> SimInitProperties:
     """Read initial properties from INIT file
     Args:
         property_file: Full path to the .INIT file
         sim_grid: The simulation grid to use for reading properties
+        fipnum_param: Name for zone/region parameter, normally 'FIPNUM'
     Returns:
         SimInitProperties: The loaded initial grid properties
     """
-    INIT_PROPS = ["PORO", "DEPTH", "NTG"]
+    init_props = ["PORO", "DEPTH", "PVTNUM"] + [fipnum_param]
     sim_init_props = xtgeo.gridproperties_from_file(
-        property_file, fformat="init", names=INIT_PROPS, grid=sim_grid
+        property_file, fformat="init", names=init_props, grid=sim_grid
     )
     props_dict = {
         sim_init_props[name].name.lower(): sim_init_props[name].values
-        for name in INIT_PROPS
+        for name in init_props
     }
     return SimInitProperties(**props_dict)
 
 
 def create_rst_list(
     rst_props: xtgeo.GridProperties,
-    seis_dates: List[str],
-    rst_prop_names: List[str],
-) -> List[SimRstProperties]:
+    seis_dates: list[str],
+    rst_prop_names: list[str],
+) -> list[SimRstProperties]:
     """Create list of SimRstProperties from raw restart properties
     Args:
         rst_props: Raw restart properties
-        seis_dates: List of dates to process
-        rst_prop_names: List of property names to include
+        seis_dates: list of dates to process
+        rst_prop_names: list of property names to include
     Returns:
-        List[SimRstProperties]: List of processed restart properties by date
+        list[SimRstProperties]: list of processed restart properties by date
     """
     return [
         SimRstProperties(
@@ -70,93 +56,95 @@ def create_rst_list(
 
 
 def read_sim_grid_props(
+    rel_dir_sim_files: Path,
     egrid_file: Path,
     init_property_file: Path,
     restart_property_file: Path,
-    seis_dates: List[str],
-) -> Tuple[xtgeo.Grid, SimInitProperties, List[SimRstProperties]]:
+    seis_dates: list[str],
+    fipnum_name: str = "FIPNUM",
+) -> tuple[xtgeo.Grid, SimInitProperties, list[SimRstProperties]]:
     """Read grid and properties from simulation run, both initial and restart properties
 
     Args:
+        rel_dir_sim_files: start dir for PEM script run
         egrid_file: Path to the EGRID file
         init_property_file: Path to the INIT file
         restart_property_file: Path to the UNRST file
-        seis_dates: List of dates for which to read restart properties
+        seis_dates: list of dates for which to read restart properties
 
     Returns:
         sim_grid: grid definition for eclipse input
         init_props: object with initial properties of simulation grid
         rst_list: list with time-dependent simulation properties
     """
-    sim_grid = xtgeo.grid_from_file(egrid_file)
+    sim_grid = xtgeo.grid_from_file(rel_dir_sim_files / egrid_file)
 
-    init_props = read_init_properties(init_property_file, sim_grid)
+    init_props = read_init_properties(
+        rel_dir_sim_files / init_property_file, sim_grid, fipnum_name
+    )
 
     # TEMP will only be available for eclipse-300
-    RST_PROPS = ["SWAT", "SGAS", "SOIL", "RS", "RV", "PRESSURE", "SALT", "TEMP"]
+    rst_props_names = ["SWAT", "SGAS", "SOIL", "RS", "RV", "PRESSURE", "SALT", "TEMP"]
 
     # Restart properties - set strict to False, False in case RV is not included in
-    # the UNRST file
+    # the UNRST file. NB: This has the effect that other missing parameters will not
+    # raise an error here, but that is handled by the following try-except statement.
     rst_props = xtgeo.gridproperties_from_file(
-        restart_property_file,
+        rel_dir_sim_files / restart_property_file,
         fformat="unrst",
-        names=RST_PROPS,
+        names=rst_props_names,
         dates=seis_dates,
         grid=sim_grid,
         strict=(False, False),
     )
 
-    rst_list = create_rst_list(rst_props, seis_dates, RST_PROPS)
-
-    return sim_grid, init_props, rst_list
+    # Formation pressure has unit `bar` in eclipse, but in the PEM models, unit
+    # `Pa` is expected. Perform unit conversion before class objects are populated
+    for date in seis_dates:
+        rst_props["PRESSURE" + "_" + date].values = bar_to_pa(
+            rst_props["PRESSURE" + "_" + date].values
+        )
 
+    try:
+        rst_list = create_rst_list(rst_props, seis_dates, rst_props_names)
+    except (AttributeError, TypeError) as e:
+        raise ValueError(f"eclipse simulator restart file is missing parameters: {e}")
 
-def read_ntg_grid(ntg_grid_file: Path) -> np.ma.MaskedArray:
-    """Read PEM specific NTG property
-    Args:
-        ntg_grid_file: path to the NTG grid file
-    Returns:
-        net to gross property from simgrid adapted to PEM definition
-    """
-    return xtgeo.gridproperty_from_file(ntg_grid_file).values
+    return sim_grid, init_props, rst_list
 
 
-def import_fractions(root_dir: Path, config: PemConfig) -> list:
+def import_fractions(
+    root_dir: Path,
+    fraction_path: Path,
+    fraction_files: list[Path],
+    fraction_names: list[str],
+    grd: xtgeo.Grid,
+) -> list:
     """Import volume fractions
 
     Args:
         root_dir (str): model directory, relative paths refer to it
-        config (PemConfig): configuration file with PEM parameters
+        fraction_path: path to the fractions files
+        fraction_files: list of fraction files
+        fraction_names: list of parameter names in fraction files
+        grd (xtgeo.Grid): model grid
 
     Returns:
         list: fraction properties
     """
-    with restore_dir(
-        root_dir.joinpath(config.rock_matrix.volume_fractions.rel_path_fractions)
-    ):
-        try:
-            grd = xtgeo.grid_from_file(
-                config.rock_matrix.volume_fractions.fractions_grid_file_name,
-            )
-        except ValueError as exc:
-            raise ImportError(
-                f"{__file__}: failed to import volume fractions file "
-                f"{config.rock_matrix.volume_fractions.fractions_grid_file_name}"
-            ) from exc
+    with restore_dir(root_dir / fraction_path):
         try:
-            fracs = config.rock_matrix.fraction_names
             grid_props = [
                 xtgeo.gridproperty_from_file(
                     file,
-                    name=name,
-                    grid=grd,
+                    name=name,  # type: ignore
+                    grid=grd,  # type: ignore
                 )
-                for name in fracs
-                for file in config.rock_matrix.volume_fractions.fractions_prop_file_names  # noqa: E501
+                for name in fraction_names
+                for file in fraction_files
             ]
         except ValueError as exc:
             raise ImportError(
-                f"{__file__}: failed to import volume fractions files "
-                f"{config.rock_matrix.volume_fractions.fractions_prop_file_names}"
+                f"{__file__}: failed to import volume fractions files {fraction_files}"
             ) from exc
     return [grid_prop.values for grid_prop in grid_props]

fmu/pem/pem_utilities/pem_class_definitions.py

@@ -1,17 +1,52 @@
-from dataclasses import dataclass, field
-from typing import Optional
+from dataclasses import dataclass, fields
+from typing import Self
 
 import numpy as np
 from numpy.ma import MaskedArray
 
 
+class PropertiesSubgridMasked:
+    """
+    Class to derive object properties in a subgrid. The mask is assumed to
+    come from a numpy masked array.
+
+    In a numpy masked array, True means masked, False means not masked
+    """
+
+    def masked_where(self: Self, mask: np.ndarray, invert_mask: bool = True) -> Self:
+        """
+            Method to derive object properties in a subgrid. The mask is assumed to
+            come from a numpy masked array.
+
+        In a numpy masked array, True means masked, False means not masked
+            Args:
+                self: object with np.ndarray or np.ma.MaskedArray attributes
+                mask: Boolean mask to apply
+                invert_mask: If True, invert the mask with ~mask
+
+            Returns:
+                New instance of the same type with masked arrays
+        """
+        actual_mask = ~mask if invert_mask else mask
+
+        field_values = {}
+        for field in fields(self):
+            value = getattr(self, field.name)
+            if value is None:
+                field_values[field.name] = None
+            else:
+                field_values[field.name] = np.ma.masked_where(actual_mask, value.data)
+        return type(self)(**field_values)
+
+
 # Eclipse simulator file classes - SimInitProperties and time step SimRstProperties
 @dataclass
-class SimInitProperties:
+class SimInitProperties(PropertiesSubgridMasked):
     poro: MaskedArray
     depth: MaskedArray
-    ntg: MaskedArray
-    ntg_pem: Optional[MaskedArray] = None
+    vsh_pem: MaskedArray | None = None
+    pvtnum: MaskedArray | None = None
+    fipnum: MaskedArray | None = None
 
     @property
     def delta_z(self) -> MaskedArray:
@@ -40,7 +75,7 @@ class SimInitProperties:
 
 
 @dataclass
-class SimRstProperties:
+class SimRstProperties(PropertiesSubgridMasked):
     swat: MaskedArray
     sgas: MaskedArray
     soil: MaskedArray
@@ -53,35 +88,45 @@ class SimRstProperties:
 
 # Elastic properties for matrix, i.e. mixed minerals and volume fractions
 @dataclass
-class MatrixProperties:
-    bulk_modulus: MaskedArray
-    shear_modulus: MaskedArray
-    dens: MaskedArray
+class EffectiveMineralProperties(PropertiesSubgridMasked):
+    bulk_modulus: MaskedArray | np.ndarray
+    shear_modulus: MaskedArray | np.ndarray
+    density: MaskedArray | np.ndarray
+
+    def __post_init__(self):
+        self.vs = np.sqrt(self.shear_modulus * self.density)
+        self.vp = np.sqrt(
+            (self.bulk_modulus + 4 / 3 * self.shear_modulus) / self.density
+        )
 
 
-# Separate class for dry rock, i.e. with porosity, can use MatrixProperties as base
+# Separate class for dry rock, can use MatrixProperties as base
 # class
 @dataclass
-class DryRockProperties(MatrixProperties):
+class DryRockProperties(EffectiveMineralProperties):
     pass
 
 
 # Acoustic properties for mixed fluids. If non-Newtonian fluids are to be considered,
 # shear modulus and vs must be added
 @dataclass
-class EffectiveFluidProperties:
+class EffectiveFluidProperties(PropertiesSubgridMasked):
     bulk_modulus: MaskedArray
-    dens: MaskedArray
+    density: MaskedArray
 
     @property
     def vp(self):
-        return np.sqrt(self.bulk_modulus / self.dens)
+        return np.sqrt(self.bulk_modulus / self.density)
 
 
 # Pressure properties - overburden, formation and effective (strictly speaking
 # differential) pressure
 @dataclass
-class PressureProperties:
+class PressureProperties(PropertiesSubgridMasked):
+    """
+    All attributes shall have unit Pa
+    """
+
     formation_pressure: MaskedArray
     effective_pressure: MaskedArray
     overburden_pressure: MaskedArray
@@ -99,15 +144,28 @@ class TwoWayTime:
 # to be defined, others can be derived from them, but this construction is needed
 # to have all properties recognised by dataclasses.asdict()
 @dataclass
-class SaturatedRockProperties:
+class SaturatedRockProperties(PropertiesSubgridMasked):
     vp: MaskedArray
     vs: MaskedArray
-    dens: MaskedArray
-    ai: MaskedArray = field(init=False)
-    si: MaskedArray = field(init=False)
-    vpvs: MaskedArray = field(init=False)
+    density: MaskedArray
+    ai: MaskedArray | None = None
+    si: MaskedArray | None = None
+    vpvs: MaskedArray | None = None
 
     def __post_init__(self):
-        self.ai = self.vp * self.dens
-        self.si = self.vs * self.dens
+        """Calculate derived properties from independent variables.
+
+        This runs both at initialization and can be called manually after
+        updating vp/vs/density arrays (e.g., after zone merging).
+        """
+        self.recalculate_derived()
+
+    def recalculate_derived(self):
+        """Recalculate derived properties (ai, si, vpvs) from current vp, vs, density.
+
+        Call this method after modifying vp, vs, or density arrays to update
+        the derived properties.
+        """
+        self.ai = self.vp * self.density
+        self.si = self.vs * self.density
         self.vpvs = self.vp / self.vs