xtgeo 4.8.0__cp313-cp313-win_amd64.whl

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,130 @@
+"""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()
+            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

xtgeo/grid3d/_gridprop_import_xtgcpprop.py

@@ -0,0 +1,168 @@
+"""GridProperty import function of xtgcpprop format."""
+
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from io import BytesIO, StringIO
+from pathlib import Path
+from struct import unpack
+from typing import TYPE_CHECKING, Any, Generator
+
+import numpy as np
+
+import xtgeo.common.sys as xsys
+from xtgeo.common import null_logger
+from xtgeo.common.constants import UNDEF, UNDEF_INT
+from xtgeo.metadata.metadata import MetaDataCPProperty
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from numpy.typing import DTypeLike
+
+    from xtgeo.io._file import FileWrapper
+
+
+@contextmanager
+def _read_from_stream(
+    stream: BytesIO | StringIO,
+    size: int | None,
+    seek: int | None,
+) -> Generator[bytes, None, None]:
+    """Helper function to read from a stream with optional seeking."""
+    was_at = stream.tell()
+    if seek is not None:
+        stream.seek(seek)
+    try:
+        data = stream.read(size)
+        yield data if isinstance(data, bytes) else data.encode()
+    finally:
+        stream.seek(was_at)
+
+
+@contextmanager
+def _read_filelike(
+    filelike: Path | BytesIO | StringIO,
+    size: int | None = None,
+    seek: int | None = None,
+) -> Generator[bytes, None, None]:
+    """Context manager for reading a specified number of bytes from a file-like object.
+
+    Accepts either a Path, BytesIO, or StringIO object as input. The function reads
+    up to 'offset' bytes from the file-like object and yields these bytes.
+
+    For BytesIO and StringIO, the read operation preserves the original
+    file cursor position.
+    """
+
+    if isinstance(filelike, Path):
+        with filelike.open("rb") as f:
+            if seek is not None:
+                f.seek(seek)
+            yield f.read(size)
+    elif isinstance(filelike, (BytesIO, StringIO)):
+        with _read_from_stream(stream=filelike, size=size, seek=seek) as f:
+            yield f
+    else:
+        raise TypeError("Filelike must be one of: Path, BytesIO or StringIO.")
+
+
+def import_xtgcpprop(
+    mfile: FileWrapper,
+    ijrange: Sequence[int] | None = None,
+    zerobased: bool = False,
+) -> dict[str, Any]:
+    """Using pure python for experimental xtgcpprop import.
+
+    Args:
+        mfile (FileWrapper): Input file reference
+        ijrange (list-like): List or tuple with 4 members [i_from, i_to, j_from, j_to]
+            where cell indices are zero based (starts with 0)
+        zerobased (bool): If ijrange basis is zero or one.
+
+    """
+    offset = 36
+
+    with _read_filelike(mfile.file, size=offset) as header:
+        # unpack header
+        swap, magic, nbyte, ncol, nrow, nlay = unpack("= i i i q q q", header)
+
+    if swap != 1 or magic not in (1351, 1352):
+        raise ValueError("Invalid file format (wrong swap id or magic number).")
+
+    if magic == 1351:
+        dtype: DTypeLike = np.float32 if nbyte == 4 else np.float64
+    else:
+        dtype = f"int{nbyte * 8}"
+
+    narr = ncol * nrow * nlay
+
+    ncolnew = nrownew = 0
+
+    if ijrange:
+        vals, ncolnew, nrownew = _import_xtgcpprop_partial(
+            mfile, nbyte, dtype, offset, ijrange, zerobased, ncol, nrow, nlay
+        )
+
+    else:
+        vals = xsys.npfromfile(mfile.file, dtype=dtype, count=narr, offset=offset)
+
+    # read metadata which will be at position offet + nfloat*narr +13
+    with _read_filelike(
+        mfile.file,
+        seek=offset + nbyte * narr + 13,
+    ) as _meta:
+        meta = json.loads(_meta, object_pairs_hook=dict)
+
+    req = meta["_required_"]
+
+    result = {att: req[att] for att in MetaDataCPProperty.REQUIRED}
+
+    if ijrange:
+        result["ncol"] = ncolnew
+        result["nrow"] = nrownew
+
+    result["values"] = np.ma.masked_equal(
+        vals.reshape((result["ncol"], result["nrow"], result["nlay"])),
+        UNDEF_INT if result["discrete"] else UNDEF,
+    )
+    return result
+
+
+def _import_xtgcpprop_partial(
+    mfile: FileWrapper,
+    nbyte: int,
+    dtype: DTypeLike,
+    offset: int,
+    ijrange: Sequence[int],
+    zerobased: bool,
+    ncol: int,
+    nrow: int,
+    nlay: int,
+) -> tuple[np.ndarray, int, int]:
+    """Partial import of a property."""
+    i1, i2, j1, j2 = ijrange
+    if not zerobased:
+        i1 -= 1
+        i2 -= 1
+        j1 -= 1
+        j2 -= 1
+
+    ncolnew = i2 - i1 + 1
+    nrownew = j2 - j1 + 1
+
+    if ncolnew < 1 or ncolnew > ncol or nrownew < 1 or nrownew > nrow:
+        raise ValueError("The ijrange spesification is invalid.")
+
+    vals = np.zeros(ncolnew * nrownew * nlay, dtype=dtype)
+
+    for newnum, inum in enumerate(range(i1, i2 + 1)):
+        newpos = offset + (inum * nrow * nlay + j1 * nlay) * nbyte
+        ncount = nrownew * nlay
+        xvals = xsys.npfromfile(mfile.file, dtype=dtype, count=ncount, offset=newpos)
+        vals[newnum * ncount : newnum * ncount + ncount] = xvals
+
+    return vals, ncolnew, nrownew

xtgeo/grid3d/_gridprop_lowlevel.py

@@ -0,0 +1,171 @@
+"""GridProperty (not GridProperies) low level functions"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import numpy.ma as ma
+
+from xtgeo import _cxtgeo
+from xtgeo.common import null_logger
+from xtgeo.common.constants import UNDEF, UNDEF_INT
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from ctypes import Array as cArray
+
+    from numpy.typing import DTypeLike
+
+    from xtgeo.grid3d import Grid, GridProperty
+
+
+def f2c_order(obj: Grid | GridProperty, values1d: np.ndarray) -> np.ndarray:
+    """Convert values1d from Fortran to C order, obj can be a Grid() or GridProperty()
+    instance
+    """
+    val = np.reshape(values1d, (obj.ncol, obj.nrow, obj.nlay), order="F")
+    val = np.asanyarray(val, order="C")
+    return val.ravel()
+
+
+def c2f_order(obj: Grid | GridProperty, values1d: np.ndarray) -> np.ndarray:
+    """Convert values1d from C to F order, obj can be a Grid() or GridProperty()
+    instance
+    """
+    val = np.reshape(values1d, (obj.ncol, obj.nrow, obj.nlay), order="C")
+    val = np.asanyarray(val, order="F")
+    return val.ravel(order="F")
+
+
+def update_values_from_carray(
+    self: GridProperty,
+    carray: cArray,
+    dtype: DTypeLike,
+    delete: bool = False,
+) -> None:
+    """Transfer values from SWIG 1D carray to numpy, 3D array"""
+
+    logger.debug("Update numpy from C array values")
+
+    nv = self.ntotal
+
+    self._isdiscrete = False
+
+    if dtype == np.float64:
+        logger.info("Entering conversion to numpy (float64) ...")
+        values1d = _cxtgeo.swig_carr_to_numpy_1d(nv, carray)
+    else:
+        logger.info("Entering conversion to numpy (int32) ...")
+        values1d = _cxtgeo.swig_carr_to_numpy_i1d(nv, carray)
+        self._isdiscrete = True
+
+    values = np.reshape(values1d, (self._ncol, self._nrow, self._nlay), order="F")
+
+    # make into C order as this is standard Python order...
+    values = np.asanyarray(values, order="C")
+
+    # make it float64 or whatever(?) and mask it
+    self.values = values  # type: ignore
+    self.mask_undef()
+
+    # optionally delete the C array if needed
+    if delete:
+        delete_carray(self, carray)
+
+
+def update_carray(
+    self: GridProperty,
+    undef: int | float | None = None,
+    discrete: bool | None = None,
+    dtype: DTypeLike = None,
+    order: Literal["C", "F", "A", "K"] = "F",
+) -> cArray:
+    """Copy (update) values from numpy to SWIG, 1D array, returns a pointer
+    to SWIG C array. If discrete is defined as True or False, force
+    the SWIG array to be of that kind.
+
+    Note that dtype will "override" current datatype if set. The resulting
+    carray will be in Fortran order, unless order is specified as 'C'
+    """
+
+    dstatus = self._isdiscrete
+    if discrete is not None:
+        dstatus = bool(discrete)
+
+    if undef is None:
+        undef = UNDEF
+        if dstatus:
+            undef = UNDEF_INT
+
+    logger.debug("Entering conversion from numpy to C array ...")
+
+    values = self.values.copy()
+
+    if not dtype:
+        values = values.astype(np.int32) if dstatus else values.astype(np.float64)
+    else:
+        values = values.astype(dtype)
+
+    values = ma.filled(values, undef)
+    values = np.asfortranarray(values)
+
+    if order == "F":
+        values = np.asfortranarray(values)
+
+    values1d = np.ravel(values, order=order)
+
+    if values1d.dtype == "float64" and dstatus and not dtype:
+        values1d = values1d.astype("int32")
+        logger.debug("Casting has been done")
+
+    if values1d.dtype == "float64":
+        logger.debug("Convert to carray (double)")
+        carray = _cxtgeo.new_doublearray(self.ntotal)
+        _cxtgeo.swig_numpy_to_carr_1d(values1d, carray)
+    elif values1d.dtype == "float32":
+        logger.debug("Convert to carray (float)")
+        carray = _cxtgeo.new_floatarray(self.ntotal)
+        _cxtgeo.swig_numpy_to_carr_f1d(values1d, carray)
+    elif values1d.dtype == "int32":
+        logger.debug("Convert to carray (int32)")
+        carray = _cxtgeo.new_intarray(self.ntotal)
+        _cxtgeo.swig_numpy_to_carr_i1d(values1d, carray)
+    else:
+        raise RuntimeError(f"Unsupported dtype, probable bug in {__name__}")
+    return carray
+
+
+def delete_carray(self: GridProperty, carray: cArray) -> None:
+    """Delete carray SWIG C pointer, return carray as None"""
+
+    logger.debug("Enter delete carray values method for %d", id(self))
+    if carray is None:
+        return
+
+    if "int" in str(carray):
+        _cxtgeo.delete_intarray(carray)
+        return
+    if "float" in str(carray):
+        _cxtgeo.delete_floatarray(carray)
+        return
+    if "double" in str(carray):
+        _cxtgeo.delete_doublearray(carray)
+        return
+
+    raise RuntimeError("BUG?")
+
+
+def check_shape_ok(self: GridProperty, values: np.ndarray) -> bool:
+    """Check if chape of values is OK"""
+    if values.shape == (self._ncol, self._nrow, self._nlay):
+        return True
+    logger.error(
+        "Wrong shape: Dimens of values %s %s %svs %s %s %s",
+        *values.shape,
+        self._ncol,
+        self._nrow,
+        self._nlay,
+    )
+    return False