fmu-pem 0.0.1__py3-none-any.whl

fmu/pem/pem_utilities/__init__.py

@@ -0,0 +1,66 @@
+from .cumsum_properties import calculate_diff_properties
+from .delta_cumsum_time import (
+    estimate_delta_time,
+    estimate_sum_delta_time,
+)
+from .export_routines import save_results
+from .import_config import get_global_params_and_dates, read_pem_config
+from .import_routines import (
+    import_fractions,
+    read_geogrid,
+    read_ntg_grid,
+    read_sim_grid_props,
+)
+from .pem_class_definitions import (
+    DryRockProperties,
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PressureProperties,
+    SaturatedRockProperties,
+    SimInitProperties,
+    SimRstProperties,
+)
+from .pem_config_validation import Fluids, PemConfig, possible_date_string
+from .update_grid import update_inactive_grid_cells
+from .utils import (
+    estimate_cement,
+    filter_and_one_dim,
+    get_shale_fraction,
+    ntg_to_shale_fraction,
+    restore_dir,
+    reverse_filter_and_restore,
+    to_masked_array,
+    update_dict_list,
+)
+
+__all__ = [
+    "PemConfig",
+    "Fluids",
+    "calculate_diff_properties",
+    "estimate_cement",
+    "estimate_sum_delta_time",
+    "estimate_delta_time",
+    "filter_and_one_dim",
+    "get_global_params_and_dates",
+    "get_shale_fraction",
+    "import_fractions",
+    "ntg_to_shale_fraction",
+    "possible_date_string",
+    "read_geogrid",
+    "read_ntg_grid",
+    "read_pem_config",
+    "read_sim_grid_props",
+    "restore_dir",
+    "reverse_filter_and_restore",
+    "save_results",
+    "to_masked_array",
+    "update_dict_list",
+    "update_inactive_grid_cells",
+    "DryRockProperties",
+    "EffectiveFluidProperties",
+    "MatrixProperties",
+    "PressureProperties",
+    "SaturatedRockProperties",
+    "SimInitProperties",
+    "SimRstProperties",
+]

fmu/pem/pem_utilities/cumsum_properties.py

@@ -0,0 +1,104 @@
+from dataclasses import asdict
+from typing import Tuple
+
+from .pem_config_validation import PemConfig
+
+
+def calculate_diff_properties(props: list, conf_params: PemConfig) -> Tuple[list, list]:
+    """
+    Function to calculate difference attributes between grid properties
+
+    :param props: grid properties
+    :param conf_params: configuration parameters
+    :return: difference of time steps according to config file
+    """
+    _verify_diff_inputs(props, conf_params)
+    props = _filter_diff_inputs(props, conf_params)
+
+    def diff(x, y):
+        return x - y
+
+    def diffpercent(x, y):
+        return 100.0 * (x - y) / y
+
+    def ratio(x, y):
+        return x / y
+
+    lookup = dict(
+        zip(
+            conf_params.global_params.seis_dates,  # type: ignore
+            range(len(conf_params.global_params.seis_dates)),  # type: ignore
+        )
+    )
+    date_str = []
+    diff_prop = []
+    # Need to iterate over the lists in props, which contain the properties
+    # for each date
+    for monitor, base in conf_params.global_params.diff_dates:  # type: ignore
+        tmp_dict = {}
+        for k, v_base in props[lookup[base]].items():
+            if k.upper() in conf_params.diff_calculation:
+                operations = conf_params.diff_calculation[k.upper()]
+                v_monitor = props[lookup[monitor]][k]
+                for op in operations:
+                    if op in locals():
+                        tmp_dict[k + op] = locals()[op](v_monitor, v_base)
+                    else:
+                        raise ValueError(
+                            f"{__file__}: unknown difference operation: {op}, should "
+                            f'be one of "diff","diff_percent" or "ratio"'
+                        )
+        if tmp_dict:
+            diff_prop.append(tmp_dict)
+            date_str.append(monitor + "_" + base)
+    return diff_prop, date_str
+
+
+def _verify_diff_inputs(prop_set, conf):
+    if not isinstance(prop_set, list):
+        raise ValueError(
+            f"{__file__}: input grid properties must be contained in a list "
+            f"of lists, with one set of properties for each simulator model "
+            f"date in the inner lists"
+        )
+    for prop_list in prop_set:
+        if len(prop_list) != len(conf.global_params.seis_dates):
+            raise ValueError(
+                f"{__file__}: mismatch between property sets and "
+                f"simulation model dates: "
+                f"{len(prop_list)} vs. {len(conf.global_params.seis_dates)}"
+            )
+    if not {a for ll in conf.global_params.diff_dates for a in ll}.issubset(
+        set(conf.global_params.seis_dates)
+    ):
+        raise ValueError(
+            f"{__file__}: trying to take difference between dates not saved from "
+            f"simulation model"
+        )
+    return
+
+
+def _filter_diff_inputs(prop_list_list, conf):
+    # Filter out the properties that are not in the diff_calculation list.
+    # Keep the time-step order in the list
+    return_list = [{} for _ in range(len(prop_list_list[0]))]
+    for prop_list in prop_list_list:
+        for i, prop_set in enumerate(prop_list):
+            tmp_dict = {
+                k: v
+                for k, v in asdict(prop_set).items()
+                if k.upper() in conf.diff_calculation
+            }
+            if tmp_dict:
+                return_list[i].update(tmp_dict)
+    if conf.global_params is None:
+        raise ValueError(
+            f"{__file__}: unable to calculate cumsum values, global "
+            f"settings are missing"
+        )
+    if conf.global_params.seis_dates is None:
+        raise ValueError(
+            f"{__file__}: unable to calculate cumsum values, global "
+            f"settings seismic dates are missing"
+        )
+    return return_list

fmu/pem/pem_utilities/delta_cumsum_time.py

@@ -0,0 +1,104 @@
+from typing import Dict, List, Union
+
+import numpy as np
+
+from .pem_class_definitions import (
+    SaturatedRockProperties,
+    SimInitProperties,
+    TwoWayTime,
+)
+from .pem_config_validation import PemConfig
+
+
+def estimate_delta_time(
+    delta_z: np.ma.MaskedArray, vp: np.ma.MaskedArray, vs: np.ma.MaskedArray
+) -> Dict[str, np.ma.MaskedArray]:
+    """Estimate seismic TWT parameters - PP, PS, SS modes
+
+    Args:
+        delta_z: delta depth cube [m]
+        vp: compressional velocity [m/s]
+        vs: shear velocity [m/s]
+
+    Returns:
+        delta PP time, delta SS time, delta PS time, all in [ms]
+    """
+    _verify_delta_t([delta_z, vp, vs])
+    dt_pp = 2000.0 * delta_z / vp
+    dt_ss = 2000.0 * delta_z / vs
+    return {"twtpp": dt_pp, "twtss": dt_ss, "twtps": (dt_pp + dt_ss) / 2.0}
+
+
+def _verify_delta_t(arrays: List[np.ma.MaskedArray]) -> None:
+    for arr in arrays:
+        if not isinstance(arr, np.ma.MaskedArray):
+            raise TypeError(
+                f"inputs to estimate_delta_time must be a numpy masked "
+                f"arrays, is {type(arr)}."
+            )
+    dim_arr = np.array([arr.shape for arr in arrays])
+    if not (dim_arr == dim_arr[0]).all():
+        raise ValueError(
+            f"{__file__}: the shape of the arrays to estimate_delta_t do not match"
+        )
+    return
+
+
+def calculate_time_cumsum(
+    props: Union[list, dict], conf_params: PemConfig
+) -> list[Dict[str, np.ma.MaskedArray]]:
+    """
+    Function to calculate cumulative sum of time difference properties
+
+    :param props: grid properties
+    :param conf_params: configuration parameters
+    :return: cumulative sum of properties along the z-axis
+    """
+    props = _verify_cumsum_inputs(props)
+    sum_prop = []
+    for prop_set in props:
+        prop_set_dict = {}
+        for k, v in prop_set.items():
+            prop_set_dict[k] = np.cumsum(v, axis=2)
+        sum_prop.append(prop_set_dict)
+
+    return sum_prop
+
+
+def _verify_cumsum_inputs(input_set):
+    if not isinstance(input_set, list):
+        input_set = [
+            input_set,
+        ]
+    for this_input in input_set:
+        if not isinstance(this_input, dict):
+            raise ValueError(
+                f"{__file__}: unexpected input type, should be dict, is "
+                f"{type(this_input)}"
+            )
+    return input_set
+
+
+def estimate_sum_delta_time(
+    constant_props: SimInitProperties,
+    sat_rock_props: List[SaturatedRockProperties],
+    config: PemConfig,
+) -> List[TwoWayTime]:
+    """Calculate TWT (two-way-time) for seismic signal for each restart date
+
+    Args:
+        constant_props: constant properties, here the delta Z property of the eclipse
+            grid is used sat_rock_props: effective properties for the saturated rock per
+            restart date
+        sat_rock_props: effective properties for the saturated rock per restart date
+        config: configuration parameters
+
+    Returns:
+        list of delta time and cumulative time per restart date
+    """
+    delta_time = [
+        estimate_delta_time(constant_props.delta_z, sat_rock.vp, sat_rock.vs)
+        for sat_rock in sat_rock_props
+    ]
+    cum_time_list = calculate_time_cumsum(delta_time, config)
+    return [TwoWayTime(**time_set) for time_set in cum_time_list]

fmu/pem/pem_utilities/enum_defs.py

@@ -0,0 +1,54 @@
+"""
+Define enumerated strings
+"""
+
+from enum import Enum
+
+
+class OverburdenPressure(str, Enum):
+    CONSTANT = "constant"
+    TREND = "trend"
+
+
+class Lithology(str, Enum):
+    SILICICLASTICS = "siliciclastics"
+    CARBONATE = "carbonate"
+
+
+class MineralMixModel(str, Enum):
+    VOIGT_REUSS_HILL = "voigt-reuss-hill"
+    HASHIN_SHTRIKMAN = "hashin-shtrikman-average"
+
+
+class FluidMixModel(str, Enum):
+    WOOD = "wood"
+    BRIE = "brie"
+
+
+class SaveTypes(str, Enum):
+    SAVE_TO_RMS = "save_results_to_rms"
+    SAVE_TO_DISK = "save_results_to_disk"
+    SAVE_INTERMEDIATE_RESULTS = "save_intermediate_results"
+    SAVE_RESULTS_TO_CSV = "save_results_to_csv"
+
+
+class CO2Models(str, Enum):
+    FLAG = "flag"
+    SPAN_WAGNER = "span_wagner"
+
+
+class RegressionModelLithologies(str, Enum):
+    SANDSTONE = "sandstone"
+    SHALE = "shale"
+
+
+class RPMType(str, Enum):
+    PATCHY_CEMENT = "patchy_cement"
+    FRIABLE = "friable"
+    T_MATRIX = "t_matrix"
+    REGRESSION = "regression"
+
+
+class VolumeFractions(str, Enum):
+    NTG_SIM = "ntg_sim"
+    VOL_FRAC = "fraction_files"

fmu/pem/pem_utilities/export_routines.py

@@ -0,0 +1,272 @@
+import warnings
+from dataclasses import asdict
+from pathlib import Path
+from typing import List, Union
+
+import xtgeo
+
+from .pem_class_definitions import (
+    EffectiveFluidProperties,
+    MatrixProperties,
+    PressureProperties,
+    SaturatedRockProperties,
+)
+from .pem_config_validation import FromGlobal, PemConfig
+from .utils import _verify_export_inputs, restore_dir
+
+
+def save_results(
+    start_dir: Path,
+    run_from_rms_flag: bool,
+    config_settings: PemConfig,
+    rms_project: object,
+    sim_grid: xtgeo.grid3d.Grid,
+    eff_pres_props: list[PressureProperties],
+    sat_rock_props: list[SaturatedRockProperties],
+    difference_props: List[dict],
+    difference_date_strs: List[str],
+    matrix_props: MatrixProperties,
+    fluid_props: list[EffectiveFluidProperties],
+) -> None:
+    """Saves all intermediate and final results according to the settings in the PEM
+    and global config files
+
+    Args:
+        start_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
+        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
+            dates
+        difference_date_strs: dates for difference calculation
+        matrix_props: intermediate results - mineral properties
+        fluid_props: intermediate results - fluid properties per time step
+
+    Returns:
+        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)
+    output_set = [
+        {
+            k: v
+            for (k, v) in asdict(sat_prop).items()  # type: ignore
+            if k.upper() in ["VP", "VS", "DENS"]
+        }
+        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,
+        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
+
+    try:
+        if config_settings.results.save_results_to_rms and run_from_rms_flag:
+            grid_model = config_settings.global_params.grid_model
+            # 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,
+                )
+            # Difference properties
+            export_results_roxar(
+                rms_project,
+                difference_props,
+                sim_grid,
+                grid_model,
+                time_steps=difference_date_strs,
+            )
+    except KeyError:  # warn user that results are not saved
+        warnings.warn(
+            f"{__file__}: no parameter for saving results to rms is found in the "
+            f"config file"
+        )
+    try:
+        if config_settings.results.save_results_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,
+                )
+            export_results_disk(
+                difference_props,
+                sim_grid,
+                config_settings.global_params.grid_model,
+                output_path,
+                time_steps=difference_date_strs,
+            )
+    except KeyError:  # warn user that results are not saved
+        warnings.warn(
+            f"{__file__}: no parameter for saving results to disk is found in the "
+            f"config file"
+        )
+
+    # 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",
+            )
+    except KeyError:
+        # just skip silently if save_intermediate_results is not present in the
+        # pem_config
+        pass
+    return
+
+
+def export_results_roxar(
+    prj: object,
+    result_props: Union[List[dict], dict],
+    grid: xtgeo.grid3d.Grid,
+    rms_grid_name: str,
+    time_steps: Union[List[str], None] = None,
+    name_suffix: str = "",
+    force_write_grid: bool = False,
+) -> None:
+    """Export results directly to RMS. Properties to be exported can be with time-steps
+        or single
+
+    Args:
+        prj: rms project
+        result_props: properties, list of or single dict, with numpy masked array
+            values
+        grid: 3D grid definition
+        rms_grid_name: name of grid within rms project
+        time_steps: list of simulation model dates, None if properties is not linked to
+            a simulation model date
+        name_suffix: extra suffix for variable names
+        force_write_grid: lag to overwrite grid model in RMS
+
+    Returns:
+        None
+    """
+    result_props, time_steps = _verify_export_inputs(result_props, grid, time_steps)
+    if force_write_grid:
+        grid.to_roxar(prj, rms_grid_name)  # type: ignore
+    else:
+        _verify_gridmodel(prj, rms_grid_name, grid)
+    for props, step in zip(result_props, time_steps):  # type: ignore
+        if step != "":
+            step = "_" + step
+        for key, value in props.items():
+            grid_property_name = key.upper() + name_suffix + step
+            grid_prop = xtgeo.grid3d.GridProperty(
+                grid, values=value, name=grid_property_name, date=step
+            )
+            grid_prop.to_roxar(prj, rms_grid_name, grid_property_name)  # type: ignore
+    return
+
+
+def _verify_gridmodel(prj: object, rms_grid_model_name: str, grid: xtgeo.grid3d.Grid):
+    if hasattr(prj, "grid_models"):
+        for model in prj.grid_models:
+            if model.name == rms_grid_model_name:
+                return
+        grid.to_roxar(prj, rms_grid_model_name)  # type: ignore
+    else:
+        raise AttributeError(
+            f'{__file__}: RMS project object does not have "grid_model" attribute '
+            f"({print(prj)})s"
+        )
+    return
+
+
+def export_results_disk(
+    result_props: Union[List[dict], dict],
+    grid: xtgeo.grid3d.Grid,
+    grid_name: str,
+    results_dir: Path,
+    time_steps: Union[List[str], None] = None,
+    name_suffix: str = "",
+    export_format: str = "roff",
+) -> None:
+    """Disk export of PEM results, all file names in lower case
+
+    Args:
+        result_props: list of dicts with properties to export
+        grid: grid definition
+        grid_name: name of grid
+        results_dir: output directory
+        time_steps: dates for simulation run
+        name_suffix: extra string suffix for export names
+        export_format: one of "roff" or "grdecl"
+
+    Returns:
+        None
+    """
+    result_props, time_steps = _verify_export_inputs(
+        result_props, grid, time_steps, export_format
+    )
+    with restore_dir(results_dir):
+        # First write the grid itself to disk
+        if export_format == "grdecl":
+            grid.to_file(grid_name.lower() + ".grdecl", fformat="grdecl")
+        else:
+            grid.to_file(grid_name.lower() + ".roff")
+        out_file = ""
+        for props, step in zip(result_props, time_steps):  # type: ignore
+            if step != "":
+                step = "--" + step
+            if export_format == "grdecl":
+                out_file = "pem" + step + ".grdecl"
+                grid.units = None
+                grid.to_file(out_file, fformat="grdecl")
+            for key, value in props.items():
+                attr_name = (
+                    grid_name.lower() + "--" + key.lower() + name_suffix.lower() + step
+                )
+                grid_prop = xtgeo.grid3d.GridProperty(
+                    grid, values=value, name=attr_name, date=step
+                )
+                if export_format == "grdecl":
+                    grid_prop.to_file(
+                        out_file, fformat="grdecl", append=True, name=key.upper()
+                    )
+                else:
+                    grid_prop.to_file(attr_name + ".roff")  # "roff" is default format

fmu/pem/pem_utilities/import_config.py

@@ -0,0 +1,93 @@
+import os
+from pathlib import Path
+
+import yaml
+
+from fmu.config.utilities import yaml_load
+
+from .pem_config_validation import PemConfig
+from .utils import restore_dir
+
+
+def get_global_params_and_dates(root_dir: Path, conf_path: Path) -> 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
+
+    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,
+        }
+
+
+def read_pem_config(yaml_file: Path) -> PemConfig:
+    """Read PEM specific parameters
+
+    Args:
+        yaml_file: file name for PEM parameters
+
+    Returns:
+        PemConfig object with PEM parameters
+    """
+
+    def join(loader, node):
+        seq = loader.construct_sequence(node)
+        return "".join([str(i) for i in seq])
+
+    # register the tag handler
+    yaml.add_constructor("!join", join)
+
+    with yaml_file.open() as f:
+        data = yaml.load(f, Loader=yaml.Loader)
+    return PemConfig(**data)