xtgeo 4.14.0__cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

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

xtgeo/grid3d/_gridprop_op1.py

@@ -0,0 +1,272 @@
+"""Various grid property operations"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Literal, Optional, Tuple, Union
+
+import numpy as np
+
+import xtgeo
+from xtgeo import _cxtgeo
+from xtgeo.common import XTGeoDialog, null_logger
+from xtgeo.grid3d import _gridprop_lowlevel as gl
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid, GridProperty
+    from xtgeo.xyz import Polygons
+
+_CoordOrValue = Union[float, int]
+_XYCoordinate = Tuple[_CoordOrValue, _CoordOrValue]
+_XYCoordList = List[List[List[_XYCoordinate]]]
+_ValueList = List[List[_CoordOrValue]]
+XYValueLists = Tuple[_XYCoordList, _ValueList]
+
+
+def _validate_cast_range(values: np.ndarray, target_dtype: np.dtype) -> None:
+    """Validate that values fit in target dtype range."""
+    if np.issubdtype(target_dtype, np.integer):
+        info = np.iinfo(target_dtype)
+        min_val, max_val = info.min, info.max
+
+        # Check actual value ranges
+        actual_min = np.nanmin(values)
+        actual_max = np.nanmax(values)
+
+        if actual_min < min_val or actual_max > max_val:
+            raise ValueError(
+                f"Values [{actual_min}, {actual_max}] exceed {target_dtype} "
+                f"range [{min_val}, {max_val}]"
+            )
+    elif np.issubdtype(target_dtype, np.floating):
+        info = np.finfo(target_dtype)
+        # Check for overflow/underflow
+        if np.any(np.abs(values[np.isfinite(values)]) > info.max):
+            raise ValueError(f"Values too large for {target_dtype}")
+
+
+def discrete_to_continuous(self: GridProperty) -> None:
+    """Convert from discrete to continuous values."""
+    if not self.isdiscrete:
+        logger.debug("No need to convert, already continuous")
+        return
+
+    logger.debug("Converting to continuous ...")
+    val = self._values.copy()
+    val = val.astype(np.float64)
+    self._values = val
+    self._isdiscrete = False
+    self._codes = {}
+    self.roxar_dtype = np.float32
+
+
+def continuous_to_discrete(self) -> None:
+    """Convert from continuous to discrete values."""
+    if self.isdiscrete:
+        logger.debug("No need to convert, already discrete")
+        return
+
+    logger.debug("Converting to discrete ...")
+    val = self._values.copy()
+
+    # Validate finite values only
+    finite_vals = (
+        val[np.isfinite(val)]
+        if not isinstance(val, np.ma.MaskedArray)
+        else val.compressed()
+    )
+    if len(finite_vals) > 0:
+        _validate_cast_range(finite_vals, np.int32)
+
+    # Round and cast, suppressing the NaN warning
+    val = np.round(val)
+    with np.errstate(invalid="ignore"):
+        val = val.astype(np.int32)
+
+    self._values = val
+    self._isdiscrete = True
+
+    self._codes = {
+        v: str(v)
+        for v in np.ma.unique(val)
+        if np.isfinite(v) and not isinstance(v, np.ma.core.MaskedConstant)
+    }
+    self.roxar_dtype = np.uint16
+
+
+def get_xy_value_lists(
+    self: GridProperty,
+    grid: Optional[Grid | GridProperty] = None,
+    mask: Optional[bool] = None,
+) -> XYValueLists:
+    """Get values for webportal format
+
+    Two cells:
+    [[[(x1,y1), (x2,y2), (x3,y3), (x4,y4)],
+    [(x5,y5), (x6,y6), (x7,y7), (x8,y8)]]]
+
+    If mask is True then inactive cells are ommited from the lists,
+    else the active cells corners will be present while the property
+    will have a -999 value.
+
+    """
+    if grid is None:
+        raise RuntimeError("Missing grid object")
+
+    if not isinstance(grid, xtgeo.grid3d.Grid):
+        raise RuntimeError("The input grid is not a XTGeo Grid instance")
+
+    if not isinstance(self, xtgeo.grid3d.GridProperty):
+        raise RuntimeError("The property is not a XTGeo GridProperty instance")
+
+    clist = grid.get_xyz_corners()
+    actnum = grid.get_actnum()
+
+    # set value 0 if actnum is 0 to facilitate later operations
+    if mask:
+        for cli in clist:
+            cli.values[actnum.values == 0] = 0
+
+    # now some numpy operations (coffee?, any?)
+    xy0 = np.column_stack((clist[0].values1d, clist[1].values1d))
+    xy1 = np.column_stack((clist[3].values1d, clist[4].values1d))
+    xy2 = np.column_stack((clist[6].values1d, clist[7].values1d))
+    xy3 = np.column_stack((clist[9].values1d, clist[10].values1d))
+
+    xyc = np.column_stack((xy0, xy1, xy2, xy3))
+    xyc = xyc.reshape(grid.nlay, grid.ncol * grid.nrow, 4, 2)
+
+    coordlist = xyc.tolist()
+
+    # remove cells that are undefined ("marked" as coordinate [0, 0] if mask)
+    coordlist = [
+        [[tuple(xy) for xy in cell if xy[0] > 0] for cell in lay] for lay in coordlist
+    ]
+
+    coordlist = [[cell for cell in lay if len(cell) > 1] for lay in coordlist]
+
+    pval = self.values1d.reshape((grid.nlay, grid.ncol * grid.nrow))
+    valuelist = pval.tolist(fill_value=-999.0)
+    if mask:
+        valuelist = [[val for val in lay if val != -999.0] for lay in valuelist]
+
+    return coordlist, valuelist
+
+
+def operation_polygons(
+    self: GridProperty,
+    poly: Polygons,
+    value: float | int,
+    opname: Literal["add", "sub", "mul", "div", "set"] = "add",
+    inside: bool = True,
+) -> None:
+    """A generic function for doing operations restricted to inside
+    or outside polygon(s).
+
+    """
+    grid = self.geometry
+    grid._set_xtgformat1()
+
+    if not isinstance(poly, xtgeo.xyz.Polygons):
+        raise ValueError("The poly input is not a Polygons instance")
+
+    # make a copy of the array which is used a "filter" or "proxy"
+    # value will be 1 inside polygons, 0 outside. Undef cells are kept as is
+    dtype = self.dtype
+
+    proxy = self.copy()
+    proxy.discrete_to_continuous()
+
+    proxy.values *= 0.0
+    cvals = gl.update_carray(proxy)
+
+    idgroups = poly.get_dataframe(copy=False).groupby(poly.pname)
+
+    for id_, grp in idgroups:
+        xcor = grp[poly.xname].values
+        ycor = grp[poly.yname].values
+
+        ier = _cxtgeo.grd3d_setval_poly(
+            xcor,
+            ycor,
+            self.ncol,
+            self.nrow,
+            self.nlay,
+            grid._coordsv,
+            grid._zcornsv,
+            grid._actnumsv,
+            cvals,
+            1,
+        )
+        if ier == -9:
+            logger.warning(f"Polygon no {id_ + 1} is not closed")
+
+    gl.update_values_from_carray(proxy, cvals, np.float64, delete=True)
+
+    if opname == "add":
+        tmp = self.values.copy() + value
+    elif opname == "sub":
+        tmp = self.values.copy() - value
+    elif opname == "mul":
+        tmp = self.values.copy() * value
+    elif opname == "div":
+        # Dividing a map of zero is always a hazzle; try to obtain 0.0
+        # as result in these cases
+        if np.isclose(value, 0.0):
+            xtg.warn(
+                "Dividing a surface with value or surface with zero "
+                "elements; may get unexpected results, try to "
+                "achieve zero values as result!"
+            )
+        with np.errstate(divide="ignore", invalid="ignore"):
+            this = np.ma.filled(self.values, fill_value=1.0)
+            that = np.ma.filled(value, fill_value=1.0)
+            mask = np.ma.getmaskarray(self.values)
+            tmp = np.true_divide(this, that)
+            tmp = np.where(np.isinf(tmp), 0, tmp)
+            tmp = np.nan_to_num(tmp)
+            tmp = np.ma.array(tmp, mask=mask)
+
+    elif opname == "set":
+        tmp = self.values.copy() * 0 + value
+
+    # convert tmp back to correct dtype
+    tmp = tmp.astype(dtype)
+
+    mask = proxy.values == 1 if inside else proxy.values == 0
+
+    self.values[mask] = tmp[mask]
+
+
+def refine(
+    self: GridProperty,
+    refine_col: int | list[int],
+    refine_row: int | list[int],
+    refine_layer: int | list[int],
+) -> None:
+    """
+    Refines the grid property values along specified columns, rows, and layers.
+    This method increases the resolution of the grid property by repeating
+    the values along the specified axes. The number of repetitions for each
+    axis can be provided as either an integer or a list of integers.
+    Args:
+        refine_col (int | list[int]): Number of times to repeat values along the
+            column axis. Can be a single integer or a list of integers specifying
+            repetitions for each column.
+        refine_row (int | list[int]): Number of times to repeat values along the row
+            axis. Can be a single integer or a list of integers specifying
+            repetitions for each row.
+        refine_layer (int | list[int]): Number of times to repeat values along the
+            layer axis. Can be a single integer or a list of integers
+            specifying repetitions for each layer.
+    Returns:
+        None: The method updates the internal grid property values in place.
+    """
+    mask = np.ma.getmaskarray(self._values)
+    values = self._values.data
+    for i, val in enumerate([refine_col, refine_row, refine_layer]):
+        values = np.repeat(values, val, axis=i)
+        mask = np.repeat(mask, val, axis=i)
+    self._values = np.ma.array(values, mask=mask)