fmu-pem 0.0.1__py3-none-any.whl

fmu/pem/pem_utilities/import_routines.py

@@ -0,0 +1,161 @@
+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}
+
+
+def read_init_properties(
+    property_file: Path, sim_grid: xtgeo.Grid
+) -> 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
+    Returns:
+        SimInitProperties: The loaded initial grid properties
+    """
+    INIT_PROPS = ["PORO", "DEPTH", "NTG"]
+    sim_init_props = xtgeo.gridproperties_from_file(
+        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
+    }
+    return SimInitProperties(**props_dict)
+
+
+def create_rst_list(
+    rst_props: xtgeo.GridProperties,
+    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
+    Returns:
+        List[SimRstProperties]: List of processed restart properties by date
+    """
+    return [
+        SimRstProperties(
+            **{
+                name.lower(): rst_props[name + "_" + date].values
+                for name in rst_prop_names
+                if name + "_" + date in rst_props.names
+            }
+        )
+        for date in seis_dates
+    ]
+
+
+def read_sim_grid_props(
+    egrid_file: Path,
+    init_property_file: Path,
+    restart_property_file: Path,
+    seis_dates: List[str],
+) -> Tuple[xtgeo.Grid, SimInitProperties, List[SimRstProperties]]:
+    """Read grid and properties from simulation run, both initial and restart properties
+
+    Args:
+        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
+
+    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)
+
+    init_props = read_init_properties(init_property_file, sim_grid)
+
+    RST_PROPS = ["SWAT", "SGAS", "SOIL", "RS", "RV", "PRESSURE", "SALT"]
+
+    # Restart properties - set strict to False, False in case RV is not included in
+    # the UNRST file
+    rst_props = xtgeo.gridproperties_from_file(
+        restart_property_file,
+        fformat="unrst",
+        names=RST_PROPS,
+        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
+
+
+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
+
+
+def import_fractions(root_dir: Path, config: PemConfig) -> list:
+    """Import volume fractions
+
+    Args:
+        root_dir (str): model directory, relative paths refer to it
+        config (PemConfig): configuration file with PEM parameters
+
+    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
+        try:
+            fracs = config.rock_matrix.fraction_names
+            grid_props = [
+                xtgeo.gridproperty_from_file(
+                    file,
+                    name=name,
+                    grid=grd,
+                )
+                for name in fracs
+                for file in config.rock_matrix.volume_fractions.fractions_prop_file_names  # noqa: E501
+            ]
+        except ValueError as exc:
+            raise ImportError(
+                f"{__file__}: failed to import volume fractions files "
+                f"{config.rock_matrix.volume_fractions.fractions_prop_file_names}"
+            ) from exc
+    return [grid_prop.values for grid_prop in grid_props]

fmu/pem/pem_utilities/pem_class_definitions.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+from numpy.ma import MaskedArray
+
+
+# Eclipse simulator file classes - SimInitProperties and time step SimRstProperties
+@dataclass
+class SimInitProperties:
+    poro: MaskedArray
+    depth: MaskedArray
+    ntg: MaskedArray
+    ntg_pem: Optional[MaskedArray] = None
+
+    @property
+    def delta_z(self) -> MaskedArray:
+        """Estimate delta depth in the vertical direction"""
+
+        def _verify_delta_z(inp_arr: MaskedArray) -> None:
+            if not isinstance(inp_arr, MaskedArray) or inp_arr.dtype.kind != "f":
+                raise TypeError(
+                    f"input to estimate_delta_z must be a 3D numpy masked "
+                    f"array with float data, is {type(inp_arr)}."
+                )
+            if np.ndim(inp_arr) != 3:
+                raise ValueError(
+                    f"{__file__}: 3-dimensional array must be input to "
+                    f"estimate_delta_z. Depth difference is calculated along the "
+                    f"third axis"
+                )
+            return
+
+        _verify_delta_z(self.depth)
+        d_z = np.zeros_like(self.depth)
+        d_z[:, :, 1:] = self.depth.data[:, :, 1:] - self.depth.data[:, :, 0:-1]
+        d_z[...] = np.clip(d_z, 0.0, a_max=None)
+        delta_z: MaskedArray = MaskedArray(d_z, mask=self.depth.mask)
+        return delta_z
+
+
+@dataclass
+class SimRstProperties:
+    swat: MaskedArray
+    sgas: MaskedArray
+    soil: MaskedArray
+    rs: MaskedArray
+    pressure: MaskedArray
+    temp: MaskedArray | None = None
+    rv: MaskedArray | None = None
+    salt: MaskedArray | None = None
+
+
+# Elastic properties for matrix, i.e. mixed minerals and volume fractions
+@dataclass
+class MatrixProperties:
+    bulk_modulus: MaskedArray
+    shear_modulus: MaskedArray
+    dens: MaskedArray
+
+
+# Separate class for dry rock, i.e. with porosity, can use MatrixProperties as base
+# class
+@dataclass
+class DryRockProperties(MatrixProperties):
+    pass
+
+
+# Acoustic properties for mixed fluids. If non-Newtonian fluids are to be considered,
+# shear modulus and vs must be added
+@dataclass
+class EffectiveFluidProperties:
+    bulk_modulus: MaskedArray
+    dens: MaskedArray
+
+    @property
+    def vp(self):
+        return np.sqrt(self.bulk_modulus / self.dens)
+
+
+# Pressure properties - overburden, formation and effective (strictly speaking
+# differential) pressure
+@dataclass
+class PressureProperties:
+    formation_pressure: MaskedArray
+    effective_pressure: MaskedArray
+    overburden_pressure: MaskedArray
+
+
+# Seismic two-way time
+@dataclass
+class TwoWayTime:
+    twtpp: MaskedArray
+    twtss: MaskedArray
+    twtps: MaskedArray
+
+
+# For isotropic elastic properties, only three independent components are needed
+# 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:
+    vp: MaskedArray
+    vs: MaskedArray
+    dens: MaskedArray
+    ai: MaskedArray = field(init=False)
+    si: MaskedArray = field(init=False)
+    vpvs: MaskedArray = field(init=False)
+
+    def __post_init__(self):
+        self.ai = self.vp * self.dens
+        self.si = self.vs * self.dens
+        self.vpvs = self.vp / self.vs