fmu-pem 0.0.1__py3-none-any.whl

fmu/pem/pem_utilities/update_grid.py

@@ -0,0 +1,54 @@
+import warnings
+from dataclasses import astuple
+
+import numpy as np
+import xtgeo
+
+from .pem_class_definitions import SaturatedRockProperties
+
+
+def update_inactive_grid_cells(
+    grid: xtgeo.grid3d.Grid,
+    props: list[SaturatedRockProperties],
+) -> xtgeo.grid3d.Grid:
+    """
+    Update the grid mask based on the mask of the properties
+
+    Args:
+        grid: original grid
+        props: list of saturated rock properties
+
+    Returns:
+        Grid with the same geometry, but with updated mask for inactive cells
+    """
+    # Make sure that the 'props' are of type SaturatedRockProperties
+    for prop in props:
+        if not isinstance(prop, SaturatedRockProperties):
+            raise ValueError(
+                f"Expected 'props' to be of type SaturatedRockProperties, got "
+                f"{type(prop)}"
+            )
+
+    grid_mask = grid.get_actnum(asmasked=True)
+
+    init_mask = np.zeros_like(grid.actnum_array).astype(bool)
+
+    for prop in props:
+        for prop_arr in astuple(prop):  # noqa: type
+            init_mask = np.logical_or(init_mask, prop_arr.mask.astype(bool))
+
+    # To match the logic in xtgeo grid actnum, the mask must be inverted
+    init_mask = np.logical_not(init_mask)
+
+    if not np.all(init_mask == grid.actnum_array.astype(bool)):
+        warnings.warn(
+            f"There are undefined values in PEM results: "
+            f"{np.sum(np.logical_xor(init_mask, grid.actnum_array.astype(bool)))} "
+            f"cells are added to the model's inactive cells. \nPlease investigate the "
+            f"PEM's intermediate and final results for a cause."
+        )
+        init_mask = np.logical_and(init_mask, grid.actnum_array.astype(bool))
+        grid_mask.values = init_mask
+        grid.set_actnum(grid_mask)
+
+    return grid

fmu/pem/pem_utilities/utils.py

@@ -0,0 +1,262 @@
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import xtgeo
+
+from .pem_class_definitions import MatrixProperties
+from .pem_config_validation import PemConfig
+
+
+@contextmanager
+def restore_dir(path: Path) -> None:
+    """restore_dir run block of code from a given path, restore original path
+
+    Args:
+        path: path where the call is made from
+
+    Returns:
+        None
+    """
+    old_pwd = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(old_pwd)
+
+
+def to_masked_array(
+    value: Union[float, int], masked_array: np.ma.MaskedArray
+) -> np.ma.MaskedArray:
+    """Create a masked array with a constant value from an int or float and a template
+    masked array
+
+    Args:
+        value: constant value for the returned masked array
+        masked_array: template for shape and mask of returned masked array
+
+    Returns:
+        constant value masked array
+    """
+    return np.ma.MaskedArray(value * np.ones_like(masked_array), mask=masked_array.mask)
+
+
+def filter_and_one_dim(
+    *args: np.ma.MaskedArray, return_numpy_array: bool = False
+) -> tuple[np.ma.MaskedArray, ...]:
+    """Filters multiple masked arrays by removing masked values and flattens them to 1D.
+
+    Typically used in preparation for calling the rock-physics library.
+
+    Args:
+        *args: One or more masked arrays of identical shape. Each array contains data
+            with some values potentially masked as invalid.
+        return_numpy_array: If True, returns regular numpy arrays instead of
+            masked arrays for the filtered data. Defaults to False.
+
+    Returns:
+        tuple containing:
+            - mask: Boolean array of the same shape as inputs where True indicates
+              positions that were masked in any of the input arrays
+            - filtered arrays: One or more 1D arrays containing only the unmasked values
+              from each input array, in their original order
+    """
+    if not np.all([isinstance(arg, np.ma.MaskedArray) for arg in args]):
+        raise ValueError(f"{__file__}: all inputs should be numpy masked arrays")
+    mask = args[0].mask
+    for i in range(1, len(args)):
+        mask = np.logical_or(mask, args[i].mask)
+    if return_numpy_array:
+        out_args = [arg[~mask].data for arg in args]
+    else:
+        out_args = [arg[~mask] for arg in args]
+    return mask, *out_args
+
+
+def reverse_filter_and_restore(
+    mask: np.ndarray, *args: np.ndarray
+) -> Tuple[np.ma.MaskedArray, ...]:
+    """Restores 1D filtered arrays back to their original shape with masking.
+
+    Typically called with results returned from the rock-physics library.
+
+    Args:
+        mask: Boolean array where True indicates positions that should be masked
+            in the restored arrays.
+        *args: One or more 1D numpy arrays containing the filtered values to be
+            restored. Each array should contain exactly enough values to fill
+            the unmasked positions in the mask.
+
+    Returns:
+        tuple of masked arrays where:
+            - Each array has the same shape as the input mask
+            - Unmasked positions contain values from the input args
+            - Masked positions (where mask is True) contain zeros and are masked
+            - All returned arrays share the same mask
+    """
+    out_args: list[np.ma.MaskedArray] = []
+    for arg in args:
+        tmp = np.zeros(mask.shape)
+        tmp[~mask] = arg
+        out_args.append(np.ma.MaskedArray(tmp, mask=mask))
+
+    return tuple(out_args)
+
+
+def _verify_export_inputs(props, grid, dates, file_format=None):
+    if file_format is not None and file_format not in ["roff", "grdecl"]:
+        raise ValueError(
+            f'{__file__}: output file format must be one of "roff", "grdecl", is '
+            f"{file_format}"
+        )
+    if not isinstance(grid, xtgeo.grid3d.Grid):
+        raise ValueError(
+            f"{__file__}: model grid is not an xtgeo 3D grid, type: {type(grid)}"
+        )
+    if isinstance(props, list):
+        if isinstance(dates, list):
+            if len(props) == len(dates):
+                return props, dates
+            raise ValueError(
+                f"{__file__}: length of property list does not match the number of "
+                f"simulation model "
+                f"dates: {len(props)} vs. {len(dates)}"
+            )
+        if dates is None:
+            return props, [""] * len(props)
+        raise ValueError(
+            f"{__file__}: unknown input type, time_steps should be None or list, is "
+            f"{type(dates)}"
+        )
+    if isinstance(props, dict):
+        props = [
+            props,
+        ]
+        if dates is None:
+            return props, [
+                "",
+            ]
+        if isinstance(dates, list) and len(dates) == 1:
+            return props, dates
+        raise ValueError(
+            f"{__file__}: single length property list does not match the number of "
+            f"simulation model "
+            f"dates: {len(dates)}"
+        )
+    raise ValueError(
+        f"{__file__}: unknown input types, result_props should be list or dict, is "
+        f"{type(props)}, time_steps should be None or list, is {type(dates)}"
+    )
+
+
+def ntg_to_shale_fraction(
+    ntg: np.ma.MaskedArray, por: np.ma.MaskedArray
+) -> np.ma.MaskedArray:
+    """Calculate sand and shale fraction from N/G property
+
+    Args:
+        ntg: net-to-gross property [fraction]
+        por: total porosity [fraction]
+
+    Returns:
+        shale fraction
+    """
+    clip_ntg: np.ma.MaskedArray = np.ma.clip(np.ma.MaskedArray(ntg), 0.0, 1.0)  # type: ignore[assignment]
+    vsh: np.ma.MaskedArray = np.ma.MaskedArray(1.0 - clip_ntg)
+    return (vsh / (1.0 - por)).clip(0.0, 1.0)
+
+
+def get_shale_fraction(
+    vol_fractions: List[np.ma.MaskedArray],
+    fraction_names: list[str],
+    shale_fraction_names: Optional[str | list[str]],
+) -> Optional[np.ma.MaskedArray]:
+    """
+
+    Args:
+        vol_fractions: volume fractions, already verified that there is consistency
+            between named fractions and available fractions in property file
+        fraction_names: names of the volume fractions
+        shale_fraction_names: Names of fractions that should be considered shale
+
+    Returns:
+        sum of volume fractions that are defined as shale, None if there are no defined
+            shale fractions
+    """
+
+    if not shale_fraction_names:
+        return None
+
+    if isinstance(shale_fraction_names, str):
+        shale_fraction_names = [shale_fraction_names]
+
+    sh_list: list[np.ma.MaskedArray] = []
+    for shale_name in shale_fraction_names:
+        try:
+            idx = fraction_names.index(shale_name)
+            sh_list.append(vol_fractions[idx])
+        except ValueError:
+            raise ValueError(f"unknown shale fraction: {shale_name}")
+
+    # Note that masked elements are set to 0 internally.
+    return np.ma.sum(sh_list, axis=0)
+
+
+def estimate_cement(
+    bulk_modulus: float | int,
+    shear_modulus: float | int,
+    density: float | int,
+    grid: np.ma.MaskedArray,
+) -> MatrixProperties:
+    """Creates masked arrays filled with constant cement properties, matching the shape
+    and mask of the input grid.
+
+    Args:
+        bulk_modulus: Bulk modulus of the cement
+        shear_modulus: Shear modulus of the cement
+        density: Density of the cement
+        grid: Template array that defines the shape and mask for the output arrays
+
+    Returns:
+        cement properties as MatrixProperties containing constant-valued masked arrays
+    """
+    cement_k = to_masked_array(bulk_modulus, grid)
+    cement_mu = to_masked_array(shear_modulus, grid)
+    cement_rho = to_masked_array(density, grid)
+    return MatrixProperties(
+        bulk_modulus=cement_k, shear_modulus=cement_mu, dens=cement_rho
+    )
+
+
+def update_dict_list(base_list: List[dict], add_list: List[dict]) -> List[dict]:
+    """Update/add new key/value pairs to dicts in list
+
+    Args:
+        base_list: original list of dicts
+        add_list: list of dicts to be added
+
+    Returns:
+        combined list of dicts
+    """
+    _verify_update_inputs(base_list, add_list)
+    for i, item in enumerate(add_list):
+        base_list[i].update(item)
+    return base_list
+
+
+def _verify_update_inputs(base, add_list):
+    if not isinstance(base, list) and isinstance(add_list, list):
+        raise TypeError(f"{__file__}: inputs are not lists")
+    if not len(base) == len(add_list):
+        raise ValueError(
+            f"{__file__}: mismatch in list lengths: base list: {len(base)} vs. added "
+            f"list: {len(add_list)}"
+        )
+    if not (
+        all(isinstance(item, dict) for item in base)
+        and all(isinstance(item, dict) for item in add_list)
+    ):
+        raise TypeError(f"{__file__}: all items in input lists are not dict")

fmu/pem/run_pem.py

@@ -0,0 +1,98 @@
+import os
+from pathlib import Path
+
+from fmu.pem import pem_functions as pem_fcns
+from fmu.pem import pem_utilities as pem_utils
+
+
+def pem_fcn(
+    start_dir: Path,
+    rel_path_pem: Path,
+    pem_config_file_name: Path,
+    run_from_rms=False,
+    proj=None,
+) -> None:
+    """
+    Run script for extended petro elastic module within sim2seis. Parameters in
+    yaml-file control the selections made in the PEM.
+
+    """
+    # Read and validate all PEM parameters
+    config = pem_utils.read_pem_config(
+        start_dir.joinpath(rel_path_pem, pem_config_file_name)
+    )
+
+    # Read necessary part of global configurations and parameters
+    config.update_with_global(
+        pem_utils.get_global_params_and_dates(
+            start_dir, config.paths.rel_path_fmu_config
+        )
+    )
+
+    # Import Eclipse simulation grid - INIT and RESTART
+    egrid_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.EGRID"
+    init_property_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.INIT"
+    restart_property_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.UNRST"
+
+    sim_grid, constant_props, time_step_props = pem_utils.read_sim_grid_props(
+        egrid_file,
+        init_property_file,
+        restart_property_file,
+        config.global_params.seis_dates,
+    )
+
+    # Calculate rock properties - fluids and minerals
+    # Fluid properties calculated for all time-steps
+    fluid_properties = pem_fcns.effective_fluid_properties(
+        time_step_props, config.fluids
+    )
+
+    # Effective mineral (matrix) properties - one set valid for all time-steps
+    vsh, matrix_properties = pem_fcns.effective_mineral_properties(
+        start_dir, config, constant_props
+    )
+    # VSH is exported with other constant results, add it to the constant properties
+    constant_props.ntg_pem = vsh
+
+    # Estimate effective pressure
+    eff_pres = pem_fcns.estimate_pressure(
+        config, constant_props, time_step_props, matrix_properties, fluid_properties
+    )
+
+    # Estimate saturated rock properties
+    sat_rock_props = pem_fcns.estimate_saturated_rock(
+        config, constant_props, eff_pres, matrix_properties, fluid_properties
+    )
+
+    # Delta and cumulative time estimates (only TWT properties are kept)
+    sum_delta_time = pem_utils.delta_cumsum_time.estimate_sum_delta_time(
+        constant_props, sat_rock_props, config
+    )
+
+    # Calculate difference properties. Possible properties are all that vary with time
+    diff_props, diff_date_strs = pem_utils.calculate_diff_properties(
+        [time_step_props, eff_pres, sat_rock_props, sum_delta_time], config
+    )
+
+    # As a precaution, update the grid mask for inactive cells, based on the saturated
+    # rock properties
+    sim_grid = pem_utils.update_inactive_grid_cells(sim_grid, sat_rock_props)
+
+    # Save results to disk or RMS project according to settings in the PEM config
+    pem_utils.save_results(
+        start_dir,
+        run_from_rms,
+        config,
+        proj,
+        sim_grid,
+        eff_pres,
+        sat_rock_props,
+        diff_props,
+        diff_date_strs,
+        matrix_properties,
+        fluid_properties,
+    )
+
+    # Restore original path
+    os.chdir(start_dir)
+    return

fmu/pem/version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)