xtgeo 4.14.1__cp313-cp313-win_amd64.whl

xtgeo/grid3d/_gridprop_export.py

@@ -0,0 +1,202 @@
+"""GridProperty export functions."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import struct
+from contextlib import ExitStack
+from typing import IO, TYPE_CHECKING, Any, Literal
+
+import numpy as np
+import resfo
+import roffio
+
+from xtgeo.common.exceptions import InvalidFileFormatError
+from xtgeo.common.log import null_logger
+from xtgeo.io._file import FileFormat, FileWrapper
+
+from ._grdecl_format import run_length_encoding
+from ._roff_parameter import RoffParameter
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+
+    from xtgeo.common.types import FileLike
+
+    from .grid_property import GridProperty
+
+logger = null_logger(__name__)
+
+
+def to_file(
+    gridprop: GridProperty,
+    pfile: FileLike,
+    fformat: Literal["roff", "roffasc", "grdecl", "bgrdecl", "xtgcpprop"] = "roff",
+    name: str | None = None,
+    append: bool = False,
+    dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
+    fmt: str | None = None,
+    rle: bool = False,
+) -> None:
+    """Export the grid property to file."""
+    logger.debug("Export property to file %s as %s", pfile, fformat)
+
+    binary = fformat in (
+        FileFormat.ROFF_BINARY.value + FileFormat.BGRDECL.value + ["xtgcpprop"]
+    )
+
+    if not name:
+        name = gridprop.name or ""
+
+    xtg_file = FileWrapper(pfile, mode="rb")
+    xtg_file.check_folder(raiseerror=OSError)
+
+    if fformat in FileFormat.ROFF_BINARY.value + FileFormat.ROFF_ASCII.value:
+        _export_roff(gridprop, xtg_file.name, name, binary, append=append)
+    elif fformat in FileFormat.GRDECL.value + FileFormat.BGRDECL.value:
+        _export_grdecl(
+            gridprop,
+            xtg_file.name,
+            name,
+            dtype=dtype or np.int32 if gridprop.isdiscrete else np.float32,
+            append=append,
+            binary=binary,
+            fmt=fmt,
+            rle=rle,
+        )
+    elif fformat == "xtgcpprop":
+        _export_xtgcpprop(gridprop, xtg_file.name)
+    else:
+        extensions = FileFormat.extensions_string(
+            [
+                FileFormat.ROFF_BINARY,
+                FileFormat.ROFF_ASCII,
+                FileFormat.GRDECL,
+                FileFormat.BGRDECL,
+            ]
+        )
+        raise InvalidFileFormatError(
+            f"File format {fformat} is invalid for type GridProperty. "
+            f"Supported formats are {extensions}."
+        )
+
+
+def _export_roff(
+    gridprop: GridProperty,
+    pfile: str | io.BytesIO | io.StringIO,
+    name: str,
+    binary: bool,
+    append: bool = False,
+) -> None:
+    if append:
+        logger.warning(
+            "Append is not implemented for roff format, defaulting to write."
+        )
+    roff = RoffParameter.from_xtgeo_grid_property(gridprop)
+    roff.name = name
+    roff.to_file(pfile, roffio.Format.BINARY if binary else roffio.Format.ASCII)
+
+
+def _export_grdecl(
+    gridprop: GridProperty,
+    pfile: str | io.BytesIO | io.StringIO,
+    name: str,
+    dtype: type[np.float32] | type[np.float64] | type[np.int32],
+    append: bool = False,
+    binary: bool = False,
+    fmt: str | None = None,
+    rle: bool = False,
+) -> None:
+    """Export ascii or binary GRDECL"""
+    vals: npt.NDArray = gridprop.values.ravel(order="F")
+    if np.ma.isMaskedArray(vals):
+        undef_export = 1 if gridprop.isdiscrete or "int" in str(dtype) else 0.0
+        vals = np.ma.filled(vals, fill_value=undef_export)
+
+    mode = "a" if append else "w"
+    if binary:
+        mode += "b"
+
+    with ExitStack() as stack:
+        fout = (
+            stack.enter_context(open(pfile, mode)) if isinstance(pfile, str) else pfile
+        )
+
+        if append:
+            fout.seek(os.SEEK_END)
+
+        if binary:
+            resfo.write(
+                fout,
+                [(name.ljust(8), vals.astype(dtype))],
+                fileformat=resfo.Format.UNFORMATTED,
+            )
+        else:
+            # Always the case when not binary
+            assert isinstance(fout, io.TextIOWrapper)
+            fout.write(f"{name}\n")
+            if rle:
+                counts, unique_values = run_length_encoding(vals)
+                for i, (count, unique_value) in enumerate(zip(counts, unique_values)):
+                    fout.write(" ")
+                    if fmt:
+                        formatted_value = fmt % unique_value
+                    elif gridprop.isdiscrete:
+                        formatted_value = str(unique_value)
+                    else:
+                        formatted_value = f"{unique_value:3e}"
+                    if count > 1:
+                        # Try to preserve the alignment
+                        text_width = len(formatted_value)
+                        new_text = f"{count}*{formatted_value.lstrip()}"
+                        formatted_value = " " * (text_width - len(new_text)) + new_text
+                    fout.write(formatted_value)
+                    if i % 6 == 5:
+                        fout.write("\n")
+            else:
+                for i, v in enumerate(vals):
+                    fout.write(" ")
+                    if fmt:
+                        fout.write(fmt % v)
+                    elif gridprop.isdiscrete:
+                        fout.write(str(v))
+                    else:
+                        fout.write(f"{v:3e}")
+                    if i % 6 == 5:
+                        fout.write("\n")
+            fout.write(" /\n")
+
+
+def _export_xtgcpprop(
+    gridprop: GridProperty, pfile: str | io.BytesIO | io.StringIO
+) -> None:
+    """Export to experimental xtgcpproperty format, python version."""
+    logger.debug("Export as xtgcpprop...")
+    gridprop._metadata.required = gridprop
+
+    magic = 1352 if gridprop.isdiscrete else 1351
+    prevalues = (1, magic, 4, gridprop.ncol, gridprop.nrow, gridprop.nlay)
+    mystruct = struct.Struct("= i i i q q q")
+    pre = mystruct.pack(*prevalues)
+
+    meta = gridprop.metadata.get_metadata()
+
+    # Convert StringIO to BytesIO as this is a binary format
+    with ExitStack() as stack:
+        if isinstance(pfile, io.StringIO):
+            data = pfile.getvalue().encode("utf-8")
+            fout: IO[Any] = io.BytesIO(data)
+        elif isinstance(pfile, io.BytesIO):
+            fout = pfile
+        else:
+            fout = stack.enter_context(open(pfile, "wb"))
+        fout.write(pre)
+        gridprop.get_npvalues1d(fill_value=gridprop.undef).astype(np.float32).tofile(
+            fout
+        )
+        fout.write("\nXTGMETA.v01\n".encode())
+        fout.write(json.dumps(meta).encode())
+
+    logger.debug("Export as xtgcpprop... done")

xtgeo/grid3d/_gridprop_import_eclrun.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+import resfo
+
+from xtgeo.io._file import FileFormat
+
+from ._find_gridprop_in_eclrun import (
+    find_gridprop_from_init_file,
+    find_gridprops_from_restart_file,
+)
+
+if TYPE_CHECKING:
+    from xtgeo.io._file import FileWrapper
+
+    from .grid import Grid
+
+
+def decorate_name(
+    name: str, dual_porosity: bool, fracture: bool, date: int | None = None
+) -> str:
+    """Decorate a property name with date and matrix/fracture.
+
+    >>> decorate_name('PORO', True, False, 19991231)
+    'POROM_19991231'
+    """
+    decorated_name = name
+    if dual_porosity:
+        if fracture:
+            decorated_name += "F"
+        else:
+            decorated_name += "M"
+
+    if date is not None:
+        decorated_name += "_" + str(date)
+    return decorated_name
+
+
+def import_gridprop_from_init(
+    pfile: FileWrapper, name: str, grid: Grid, fracture: bool = False
+) -> dict[str, Any]:
+    """Import one parameter with the given name from an init file.
+
+    Args:
+        pfile: The init file.
+        name: The name of the parmaeter
+        grid: The grid used by the simulator to produce the init file.
+        fracture: If a dual porosity module, indicates that the fracture
+            (as apposed to the matrix) grid property should be imported.
+
+    Raises:
+        ValueError: If the parameter does not exist in the file.
+
+    Returns:
+        GridProperty parameter dictionary.
+    """
+    init_props = find_gridprop_from_init_file(pfile.file, [name], grid, fracture)
+    if len(init_props) != 1:
+        raise ValueError(f"Could not find property {name} in {pfile}")
+    init_props[0]["name"] = decorate_name(
+        init_props[0]["name"], grid.dualporo, fracture
+    )
+    return init_props[0]
+
+
+def sanitize_date(
+    date: int | str | Literal["first", "last"],
+) -> list[int] | Literal["first", "last"]:
+    """
+    Converts dateformats of the form 'YYYY-MM-DD', 'YYYYMMDD' or YYYYMMDD to
+    list of integers of the form [YYYYMMDD] (ie. suitible for find_gridprops
+    functions), but lets the special literals 'first' and 'last' remain
+    unchanged.
+
+    >>> sanitize_date('first')
+    'first'
+    >>> sanitize_date('last')
+    'last'
+    >>> sanitize_date('2020-01-01')
+    [20200101]
+    >>> sanitize_date('20200101')
+    [20200101]
+    >>> sanitize_date(20200101)
+    [20200101]
+    """
+    if isinstance(date, int):
+        return [date]
+    if date not in ("first", "last"):
+        try:
+            if (
+                isinstance(date, str)
+                and len(date) == 10
+                and date[4] == "-"
+                and date[7] == "-"
+            ):
+                date = date.replace("-", "")
+            return [int(date)]
+        except ValueError as err:
+            raise ValueError(
+                "valid dates are either of the "
+                "form 'YYYY-MM-DD', 'YYYYMMDD' or 'first'/'last' "
+                f"got {date}"
+            ) from err
+    # Satisfy mypy that we're not returning a str
+    return "first" if date == "first" else "last"
+
+
+def sanitize_fformat(fformat: FileFormat) -> resfo.Format:
+    """Converts 'unrst' and 'funrst' to the corresponding resfo.Format.
+
+    >>> sanitize_fformat('unrst')
+    <Format.UNFORMATTED: 2>
+    >>> sanitize_fformat('funrst')
+    <Format.FORMATTED: 1>
+    """
+    if fformat == FileFormat.UNRST:
+        return resfo.Format.UNFORMATTED
+    if fformat == FileFormat.FUNRST:
+        return resfo.Format.FORMATTED
+    raise ValueError(f"fformat must be either 'unrst' or 'funrst' got {fformat}")
+
+
+def import_gridprop_from_restart(
+    pfile: FileWrapper,
+    name: str,
+    grid: Grid,
+    date: int | str | Literal["first", "last"],
+    fracture: bool = False,
+    fformat: FileFormat = FileFormat.UNRST,
+) -> dict[str, Any]:
+    """Import one parameter for the given name and date in a restart file.
+
+    Args:
+        pfile: The restart file.
+        name: The name of the parmaeter
+        date: xtgeo style date (e.g. int(19990101) or "YYYYMMDD"), also
+            accepts "YYYY-MM-DD".  "last" and "first" can be given for
+            last or first date in the file
+        grid: The grid used by the simulator to produce the restart file.
+        fracture: If a dual porosity module, indicates that the fracture
+            (as apposed to the matrix) grid property should be imported.
+    Raises:
+        ValueError: If the parameter does not exist in the file.
+
+    Returns:
+        GridProperty parameter dictionary.
+    """
+    restart_props = find_gridprops_from_restart_file(
+        pfile.file,
+        [name],
+        sanitize_date(date),
+        grid,
+        fracture,
+        sanitize_fformat(fformat),
+    )
+    if len(restart_props) == 0:
+        raise ValueError(f"Could not find property {name} for {date} in {pfile.file}")
+    if len(restart_props) > 1:
+        raise ValueError(f"Ambiguous property {name} for {date} in {pfile.file}")
+    restart_props[0]["name"] = decorate_name(
+        restart_props[0]["name"], grid.dualporo, fracture, restart_props[0]["date"]
+    )
+    return restart_props[0]

xtgeo/grid3d/_gridprop_import_grdecl.py

@@ -0,0 +1,132 @@
+"""Importing grid props from GRDECL, ascii or binary"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import numpy.ma as ma
+import resfo
+
+from xtgeo.common import null_logger
+from xtgeo.common.exceptions import KeywordNotFoundError
+
+from ._grdecl_format import match_keyword, open_grdecl
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.common.types import FileLike
+    from xtgeo.io._file import FileWrapper
+
+    from .grid import Grid
+
+
+def import_bgrdecl_prop(pfile: FileWrapper, name: str, grid: Grid) -> dict[str, Any]:
+    """Import prop for binary files with GRDECL layout.
+
+    Args:
+        pfile (_XTgeoCFile): xtgeo file instance
+        name (str): Name of parameter.
+        grid (Grid()): XTGeo Grid instance.
+
+    Raises:
+        KeywordNotFoundError: Cannot find property...
+
+    Returns:
+        GridProperty parameter dictionary.
+    """
+    result: dict[str, Any] = {}
+    result["ncol"] = grid.ncol
+    result["nrow"] = grid.nrow
+    result["nlay"] = grid.nlay
+    result["name"] = name
+    result["filesrc"] = pfile
+
+    for entry in resfo.lazy_read(pfile.file):
+        if match_keyword(entry.read_keyword(), name):
+            values = entry.read_array()
+            if isinstance(values, resfo.MessType):
+                raise ValueError(f"Unexpected MESS value in {pfile.file}")
+            result["discrete"] = np.issubdtype(values.dtype, np.integer)
+            if result["discrete"]:
+                uniq = np.unique(values).tolist()
+                codes = dict(zip(uniq, uniq))
+                codes = {key: str(val) for key, val in codes.items()}  # val: strings
+                result["codes"] = codes
+                values = values.astype(np.int32)
+                result["roxar_dtype"] = np.uint16
+            else:
+                values = values.astype(np.float64)
+                result["codes"] = {}
+                result["roxar_dtype"] = np.float32
+            result["values"] = ma.masked_where(
+                grid.get_actnum().values < 1, values.reshape(grid.dimensions, order="F")
+            )
+            return result
+
+    raise KeywordNotFoundError(f"Cannot find property name {name} in file {pfile.name}")
+
+
+def read_grdecl_3d_property(
+    filename: FileLike,
+    keyword: str,
+    dimensions: tuple[int, int, int],
+    dtype: type[float] | type[int] = float,
+) -> np.ndarray:
+    """
+    Read a 3d grid property from a grdecl file, see open_grdecl for description
+    of format.
+
+    Args:
+        filename (pathlib.Path or str): File in grdecl format.
+        keyword (str): The keyword of the property in the file
+        dimensions ((int,int,int)): Triple of the size of grid.
+        dtype (function): The datatype to be read, ie., float.
+
+    Returns:
+        numpy array with given dimensions and data type read
+        from the grdecl file.
+
+    Raises:
+        KeywordNotFoundError: If keyword is not found in the file.
+    """
+    with open_grdecl(filename, keywords=[], simple_keywords=[keyword]) as kw_generator:
+        try:
+            _, result = next(kw_generator)
+        except StopIteration as si:
+            raise KeywordNotFoundError(
+                f"Cannot import {keyword}, not present in file {filename}?"
+            ) from si
+
+    # The values are stored in F order in the grdecl file
+    f_order_values = np.array([dtype(v) for v in result])
+    return np.ascontiguousarray(f_order_values.reshape(dimensions, order="F"))
+
+
+def import_grdecl_prop(pfile: FileWrapper, name: str, grid: Grid) -> dict[str, Any]:
+    """Import prop for ascii files with GRDECL layout.
+
+    Args:
+        pfile (_XTgeoCFile): xtgeo file instance
+        name (str): Name of parameter.
+        grid (Grid()): XTGeo Grid instance.
+
+    Raises:
+        KeywordNotFoundError: Cannot find property...
+
+    Returns:
+        GridProperty parameter dictionary.
+    """
+    result: dict[str, Any] = {}
+    result["ncol"] = grid.ncol
+    result["nrow"] = grid.nrow
+    result["nlay"] = grid.nlay
+    result["name"] = name
+    result["filesrc"] = pfile
+    actnumv = grid.get_actnum().values
+
+    result["values"] = ma.masked_where(
+        actnumv == 0, read_grdecl_3d_property(pfile.file, name, grid.dimensions, float)
+    )
+    return result

xtgeo/grid3d/_gridprop_import_roff.py

@@ -0,0 +1,52 @@
+"""Importing grid props from ROFF, binary"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from xtgeo.common import null_logger
+
+from ._roff_parameter import RoffParameter
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+    from xtgeo.io._file import FileWrapper
+
+logger = null_logger(__name__)
+
+
+def import_roff(
+    pfile: FileWrapper,
+    name: str | None = None,
+    grid: Grid | None = None,
+) -> dict[str, Any]:
+    """Import ROFF format"""
+    result: dict[str, Any] = {}
+    roff_param = RoffParameter.from_file(pfile._file, name)
+    result["codes"] = roff_param.xtgeo_codes()
+    result["name"] = roff_param.name
+    result["ncol"] = int(roff_param.nx)
+    result["nrow"] = int(roff_param.ny)
+    result["nlay"] = int(roff_param.nz)
+    result["discrete"] = roff_param.is_discrete
+    result["values"] = roff_param.xtgeo_values()
+
+    if grid is not None and (actnum := grid.get_actnum()):
+        result["values"] = np.ma.masked_where(
+            actnum.values < 1,
+            result["values"],
+        )
+
+    roff_val = roff_param.values
+    if isinstance(roff_val, bytes) or np.issubdtype(roff_val.dtype, np.uint8):
+        result["roxar_dtype"] = np.uint8
+    elif np.issubdtype(roff_val.dtype, np.integer):
+        result["roxar_dtype"] = np.uint16
+    elif np.issubdtype(roff_val.dtype, np.floating):
+        result["roxar_dtype"] = np.float32
+    else:
+        raise ValueError(f"Could not deduce roxar type of {roff_val.dtype}")
+
+    return result