xtgeo 4.13.1__cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/grid3d/_grid3d.py

@@ -0,0 +1,29 @@
+"""Private baseclass for Grid and GridProperties, not to be used by itself."""
+
+from xtgeo.common import XTGeoDialog
+
+xtg = XTGeoDialog()
+
+
+class _Grid3D:
+    """Abstract base class for Grid3D."""
+
+    def __init__(self, ncol: int = 4, nrow: int = 3, nlay: int = 5):
+        self._ncol = ncol
+        self._nrow = nrow
+        self._nlay = nlay
+
+    @property
+    def ncol(self) -> int:
+        """Returns the NCOL (NX or Ncolumns) number of cells."""
+        return self._ncol
+
+    @property
+    def nrow(self) -> int:
+        """Returns the NROW (NY or Nrows) number of cells."""
+        return self._nrow
+
+    @property
+    def nlay(self) -> int:
+        """Returns the NLAY (NZ or Nlayers) number of cells."""
+        return self._nlay

xtgeo/grid3d/_grid3d_fence.py

@@ -0,0 +1,284 @@
+"""Some grid utilities, file scanning etc."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from xtgeo import _cxtgeo
+from xtgeo.common import null_logger
+from xtgeo.common.constants import UNDEF_LIMIT
+from xtgeo.grid3d import _gridprop_lowlevel as gl
+from xtgeo.surface import _regsurf_lowlevel as rl
+from xtgeo.surface.regular_surface import surface_from_grid3d
+from xtgeo.xyz import Polygons
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid, GridProperty
+
+
+logger = null_logger(__name__)
+
+
+def _process_fencespec(
+    self: Grid,
+    fencespec: np.ndarray | Polygons,
+    hincrement: float | int | None,
+    atleast: int,
+    nextend: int,
+) -> np.ndarray:
+    if isinstance(fencespec, np.ndarray):
+        return fencespec
+
+    if hincrement is not None and not isinstance(hincrement, (float, int)):
+        raise TypeError("'hincrement' can only be a number or None")
+
+    if isinstance(fencespec, Polygons):
+        return _get_randomline_fence(self, fencespec, hincrement, atleast, nextend)
+
+    raise RuntimeError(
+        "The 'fencespec' argument must be a numpy array or a Polygons instance."
+    )
+
+
+def get_randomline(
+    self: Grid,
+    fencespec: np.ndarray | Polygons,
+    prop: str | GridProperty,
+    zmin: float | int | None = None,
+    zmax: float | int | None = None,
+    zincrement: float | int = 1.0,
+    hincrement: float | int | None = None,
+    atleast: int = 5,
+    nextend: int = 2,
+) -> tuple[float, float, float, float, np.ndarray]:
+    import os
+
+    # keep the old method as hidden for reference since it proves to be faster in some
+    # real cases. Need to fully understand this to optimise the new, but will postpone
+    # this for now. TODO: remove this after a while when the new version is fully tested
+    if os.environ.get("XTGEO_RANDOMLINE_OLD", None):
+        return _get_randomline_old(
+            self, fencespec, prop, zmin, zmax, zincrement, hincrement, atleast, nextend
+        )
+
+    logger.info("New version")
+    return _get_randomline_v2(
+        self, fencespec, prop, zmin, zmax, zincrement, hincrement, atleast, nextend
+    )
+
+
+def _get_randomline_v2(
+    self: Grid,
+    fencespec: np.ndarray | Polygons,
+    prop: str | GridProperty,
+    zmin: float | int | None = None,
+    zmax: float | int | None = None,
+    zincrement: float | int = 1.0,
+    hincrement: float | int | None = None,
+    atleast: int = 5,
+    nextend: int = 2,
+) -> tuple[float, float, float, float, np.ndarray]:
+    #
+    fencespec = _process_fencespec(self, fencespec, hincrement, atleast, nextend)
+
+    cache = self._get_cache()
+
+    logger.info("Get property...")
+    if isinstance(prop, str):
+        grid_prop = self.get_prop_by_name(prop)
+        if grid_prop is None:
+            raise ValueError(f"No property with name {prop} was found in grid")
+        prop = grid_prop
+
+    assert isinstance(fencespec, np.ndarray)
+
+    assert cache.top_depth is not None  # mypy
+    assert cache.base_depth is not None  # mypy
+    if zmin is None:
+        zmin = cache.top_depth.values.min()
+    if zmax is None:
+        zmax = cache.base_depth.values.max()
+
+    nzsam = int((zmax - zmin) / float(zincrement)) + 1
+    z_vector = np.linspace(zmin, zmax, nzsam)
+
+    arr = self._get_grid_cpp().get_grid_fence(
+        cache.onegrid_cpp,
+        fencespec,
+        prop.values,
+        z_vector,
+        cache.top_i_index_cpp,
+        cache.top_j_index_cpp,
+        cache.base_i_index_cpp,
+        cache.base_j_index_cpp,
+        cache.top_depth_cpp,
+        cache.base_depth_cpp,
+        cache.threshold_magic_1,
+    )
+
+    return (fencespec[3, 0], fencespec[3, -1], zmin, zmax, arr.T)
+
+
+def _get_randomline_fence(
+    self: Grid,
+    polygon: Polygons,
+    distance: float | int | None,
+    atleast: int,
+    nextend: int,
+) -> np.ndarray:
+    """Compute a resampled fence from a Polygons instance."""
+    if distance is None:
+        logger.debug("Estimate fence distance from grid resolution...")
+        geom = self.get_geometrics()
+
+        avgdxdy = 0.5 * (geom[10] + geom[11])
+        distance = 0.5 * avgdxdy
+        logger.debug("Estimate fence distance from grid resolution... DONE")
+
+    logger.debug("Getting fence from a Polygons instance...")
+    fspec = polygon.get_fence(
+        distance=distance, atleast=atleast, nextend=nextend, asnumpy=True
+    )
+    logger.debug("Getting fence from a Polygons instance... DONE")
+    return fspec
+
+
+# keep a while for benchmarking
+def _get_randomline_old(
+    self: Grid,
+    fencespec: np.ndarray | Polygons,
+    prop: str | GridProperty,
+    zmin: float | int | None = None,
+    zmax: float | int | None = None,
+    zincrement: float | int = 1.0,
+    hincrement: float | int | None = None,
+    atleast: int = 5,
+    nextend: int = 2,
+) -> tuple[float, float, float, float, np.ndarray]:
+    """Extract a randomline from a 3D grid.
+
+    This is a difficult task, in particular in terms of acceptable speed.
+    """
+
+    logger.info("Enter get_randomline OLD from Grid...")
+
+    _update_tmpvars(self, force=True)
+
+    if hincrement is not None and not isinstance(hincrement, (float, int)):
+        raise TypeError("'hincrement' can only be a number or None")
+
+    if isinstance(fencespec, Polygons):
+        fencespec = _get_randomline_fence(self, fencespec, hincrement, atleast, nextend)
+
+    logger.info("Get property...")
+    if isinstance(prop, str):
+        grid_prop = self.get_prop_by_name(prop)
+        if grid_prop is None:
+            raise ValueError(f"No property with name {prop} was found in grid")
+        prop = grid_prop
+
+    assert isinstance(fencespec, np.ndarray)
+    xcoords = fencespec[:, 0]
+    ycoords = fencespec[:, 1]
+    hcoords = fencespec[:, 3]
+
+    if zmin is None:
+        zmin = self._tmp["topd"].values.min()
+    if zmax is None:
+        zmax = self._tmp["basd"].values.max()
+
+    print("ZICREMENT", zincrement)
+
+    nzsam = int((zmax - zmin) / float(zincrement)) + 1
+    nsamples = xcoords.shape[0] * nzsam
+
+    logger.info("Running C routine to get randomline...")
+    self._set_xtgformat1()
+    self._tmp["onegrid"]._set_xtgformat1()
+    _ier, values = _cxtgeo.grd3d_get_randomline(
+        xcoords,
+        ycoords,
+        zmin,
+        zmax,
+        nzsam,
+        self._tmp["topd"].ncol,
+        self._tmp["topd"].nrow,
+        self._tmp["topd"].xori,
+        self._tmp["topd"].yori,
+        self._tmp["topd"].xinc,
+        self._tmp["topd"].yinc,
+        self._tmp["topd"].rotation,
+        self._tmp["topd"].yflip,
+        self._tmp["topi_carr"],
+        self._tmp["topj_carr"],
+        self._tmp["basi_carr"],
+        self._tmp["basj_carr"],
+        self.ncol,
+        self.nrow,
+        self.nlay,
+        self._coordsv,
+        self._zcornsv,
+        self._actnumsv,
+        gl.update_carray(prop, dtype=np.float64),
+        self._tmp["onegrid"]._zcornsv,
+        self._tmp["onegrid"]._actnumsv,
+        nsamples,
+    )
+
+    logger.info("Running C routine to get randomline... DONE")
+
+    values[values > UNDEF_LIMIT] = np.nan
+    arr = values.reshape((xcoords.shape[0], nzsam)).T
+
+    logger.info("Getting randomline... DONE")
+    return (hcoords[0], hcoords[-1], zmin, zmax, arr)
+
+
+def _update_tmpvars(self: Grid, force: bool = False) -> None:
+    """The self._tmp variables are needed to speed up calculations.
+
+    If they are already created, the no need to recreate
+    """
+    if "onegrid" not in self._tmp or force:
+        logger.info("Make a tmp onegrid instance...")
+        self._tmp["onegrid"] = self.copy()
+        self._tmp["onegrid"]._set_xtgformat1()
+        self._tmp["onegrid"].reduce_to_one_layer()
+        one = self._tmp["onegrid"]
+        logger.info("Make a tmp onegrid instance... DONE")
+        logger.info("Make a set of tmp surfaces for I J locations + depth...")
+        self._tmp["topd"] = surface_from_grid3d(
+            one, where="top", property="depth", rfactor=4, index_position="top"
+        )
+        self._tmp["topi"] = surface_from_grid3d(
+            one, where="top", property="i", rfactor=4, index_position="top"
+        )
+        self._tmp["topj"] = surface_from_grid3d(
+            one, where="top", property="j", rfactor=4, index_position="top"
+        )
+        self._tmp["basd"] = surface_from_grid3d(
+            one, where="base", property="depth", rfactor=4, index_position="base"
+        )
+        self._tmp["basi"] = surface_from_grid3d(
+            one, where="base", property="i", rfactor=4, index_position="base"
+        )
+        self._tmp["basj"] = surface_from_grid3d(
+            one, where="base", property="j", rfactor=4, index_position="base"
+        )
+
+        self._tmp["topi"].fill()
+        self._tmp["topj"].fill()
+        self._tmp["basi"].fill()
+        self._tmp["basj"].fill()
+
+        self._tmp["topi_carr"] = rl.get_carr_double(self._tmp["topi"])
+        self._tmp["topj_carr"] = rl.get_carr_double(self._tmp["topj"])
+        self._tmp["basi_carr"] = rl.get_carr_double(self._tmp["basi"])
+        self._tmp["basj_carr"] = rl.get_carr_double(self._tmp["basj"])
+
+        self._tmp["onegrid"]._set_xtgformat1()
+        logger.info("Make a set of tmp surfaces for I J locations + depth... DONE")
+    else:
+        logger.info("Re-use existing onegrid and tmp surfaces for I J")

xtgeo/grid3d/_grid3d_utils.py

@@ -0,0 +1,228 @@
+"""Some grid utilities, file scanning etc (methods with no class)"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import pandas as pd
+import resfo
+import roffio
+
+from xtgeo.common import null_logger
+from xtgeo.common.constants import MAXDATES, MAXKEYWORDS
+
+if TYPE_CHECKING:
+    from xtgeo.io._file import FileWrapper
+
+    from .grid_properties import GridPropertiesKeywords, KeywordDateTuple, KeywordTuple
+
+logger = null_logger(__name__)
+
+
+def scan_keywords(
+    pfile: FileWrapper,
+    fformat: Literal["xecl", "roff"] = "xecl",
+    maxkeys: int = MAXKEYWORDS,
+    dataframe: bool = False,
+    dates: bool = False,
+) -> GridPropertiesKeywords:
+    """Quick scan of keywords in Eclipse binary restart/init/... file,
+    or ROFF binary files.
+
+    Cf. grid_properties.py description
+    """
+    if fformat not in ("xecl", "roff"):
+        raise ValueError(f"File format can be either `roff` or `xecl`, given {fformat}")
+
+    if fformat == "roff":
+        return _scan_roff_keywords(pfile, maxkeys=maxkeys, dataframe=dataframe)
+    return (
+        _scan_ecl_keywords_w_dates(pfile, maxkeys=maxkeys, dataframe=dataframe)
+        if dates
+        else _scan_ecl_keywords(pfile, maxkeys=maxkeys, dataframe=dataframe)
+    )
+
+
+def scan_dates(
+    pfile: FileWrapper,
+    maxdates: int = MAXDATES,
+    dataframe: bool = False,
+) -> list | pd.DataFrame:
+    """Quick scan dates in a simulation restart file.
+
+    Cf. grid_properties.py description
+    """
+    dates = []
+    seqnum = -1
+    for item in resfo.lazy_read(pfile.file):
+        kw = item.read_keyword().strip()
+        data = item.read_array()
+
+        if kw == "SEQNUM":
+            seqnum = data[0]
+            continue
+
+        # With LGRs multiple INTEHEADs may occur. Ensure we get the date
+        # from the first INTEHEAD after a SEQNUM.
+        if kw == "INTEHEAD" and seqnum != -1:
+            # Index 66 = year, 65 = month, 64 = day
+            date = int(f"{data[66]}{data[65]:02d}{data[64]:02d}")
+            dates.append((seqnum, date))
+            seqnum = -1
+
+    return (
+        pd.DataFrame.from_records(dates, columns=["SEQNUM", "DATE"])
+        if dataframe
+        else dates
+    )
+
+
+def _scan_ecl_keywords(
+    pfile: FileWrapper,
+    maxkeys: int = MAXKEYWORDS,
+    dataframe: bool = False,
+) -> list[KeywordTuple] | pd.DataFrame:
+    keywords = []
+    for item in resfo.lazy_read(pfile.file):
+        keywords.append(
+            (
+                item.read_keyword().strip(),
+                item.read_type().strip(),
+                item.read_length(),
+                item.stream.tell(),
+            )
+        )
+
+    return (
+        pd.DataFrame.from_records(
+            keywords,
+            columns=["KEYWORD", "TYPE", "NITEMS", "BYTESTART"],
+        )
+        if dataframe
+        else keywords
+    )
+
+
+def _scan_ecl_keywords_w_dates(
+    pfile: FileWrapper,
+    maxkeys: int = MAXKEYWORDS,
+    dataframe: bool = False,
+) -> list[KeywordDateTuple] | pd.DataFrame:
+    """Add a date column to the keyword"""
+    xkeys = _scan_ecl_keywords(pfile, maxkeys=maxkeys, dataframe=False)
+    assert isinstance(xkeys, list)
+    xdates = scan_dates(pfile, maxdates=MAXDATES, dataframe=False)
+    assert isinstance(xdates, list)
+
+    result = []
+    # now merge these two:
+    nv = -1
+    date = 0
+    for item in xkeys:
+        name, dtype, reclen, bytepos = item
+        if name == "SEQNUM":
+            nv += 1
+            date = xdates[nv][1]
+
+        entry = (name, dtype, reclen, bytepos, date)
+        result.append(entry)
+
+    return (
+        pd.DataFrame.from_records(
+            result,
+            columns=["KEYWORD", "TYPE", "NITEMS", "BYTESTART", "DATE"],
+        )
+        if dataframe
+        else result
+    )
+
+
+def _scan_roff_keywords(
+    pfile: FileWrapper,
+    maxkeys: int = MAXKEYWORDS,
+    dataframe: bool = False,
+) -> list[KeywordTuple] | pd.DataFrame:
+    with open(pfile.file, "rb") as fin:
+        is_binary = fin.read(8) == b"roff-bin"
+
+    keywords = []
+    with roffio.lazy_read(pfile.file) as roff_iter:
+        SPACE_OR_NUL = 1
+        TAG = 3 + SPACE_OR_NUL  # "tag"
+        ENDTAG = 6 + SPACE_OR_NUL  # "endtag"
+        ARRAY_AND_SIZE = 5 + SPACE_OR_NUL + 4  # "array", 4 byte int
+
+        count = 0
+        done = False
+        # 81 is where the standard RMS exported header size ends.
+        # This offset won't be correct for non-RMS exported roff files,
+        # but it is a compromise to keep the old functionality of byte
+        # counting _close enough_ because this data is not made available
+        # from roffio.
+        byte_pos = 81
+
+        for tag_name, tag_group in roff_iter:
+            byte_pos += TAG
+            byte_pos += len(tag_name) + SPACE_OR_NUL
+
+            for keyword, value in tag_group:
+                if isinstance(value, (np.ndarray, bytes)):
+                    byte_pos += ARRAY_AND_SIZE
+                dtype, size, offset = _get_roff_type_and_size(value, is_binary)
+
+                byte_pos += len(dtype) + SPACE_OR_NUL
+                byte_pos += len(keyword) + SPACE_OR_NUL
+
+                keyword = f"{tag_name}!{keyword}"
+                if tag_name == "parameter" and keyword == "name":
+                    keyword += f"!{value}"
+                keywords.append((keyword, dtype, size, byte_pos))
+
+                byte_pos += offset
+                count += 1
+                if count == maxkeys:
+                    done = True
+                    break
+
+            byte_pos += ENDTAG
+            if done:
+                break
+
+    return (
+        pd.DataFrame.from_records(
+            keywords,
+            columns=["KEYWORD", "TYPE", "NITEMS", "BYTESTARTDATA"],
+        )
+        if dataframe
+        else keywords
+    )
+
+
+def _get_roff_type_and_size(
+    value: str | bool | bytes | np.ndarray, is_binary: bool
+) -> tuple[str, int, int]:
+    # If is_binary is False add a multiplier because values will
+    # be separated by spaces in the case of numerical/boolean
+    # data, as opposed to buffer packed, while strings will be
+    # quoted and not just NUL delimited
+    if isinstance(value, str):
+        return "char", 1, len(value) + (1 if is_binary else 3)
+    if isinstance(value, bool):
+        return "bool", 1, 1 if is_binary else 2
+    if isinstance(value, bytes):
+        return "byte", len(value), len(value) * (1 if is_binary else 2)
+    if np.issubdtype(value.dtype, np.bool_):
+        return "bool", value.size, value.size * (1 if is_binary else 2)
+    if np.issubdtype(value.dtype, np.int8) or np.issubdtype(value.dtype, np.uint8):
+        return "byte", value.size, value.size * (1 if is_binary else 2)
+    if np.issubdtype(value.dtype, np.integer):
+        return "int", value.size, value.size * (4 if is_binary else 5)
+    if np.issubdtype(value.dtype, np.float32):
+        return "float", value.size, value.size * (4 if is_binary else 5)
+    if np.issubdtype(value.dtype, np.double):
+        return "double", value.size, value.size * (8 if is_binary else 9)
+    if np.issubdtype(value.dtype, np.str_):
+        total_bytes = sum(len(val) + (1 if is_binary else 3) for val in value)
+        return "char", value.size, total_bytes
+    raise ValueError(f"Could not find suitable roff type for {type(value)}")

xtgeo/grid3d/_grid_boundary.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from xtgeo.xyz.points import Points
+from xtgeo.xyz.polygons import Polygons
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+def create_boundary(
+    grid: Grid,
+    alpha_factor: float = 1.0,
+    convex: bool = False,
+    simplify: bool | dict[str, Any] = True,
+    filter_array: np.ndarray | None = None,
+) -> Polygons:
+    """Create boundary polygons for a grid."""
+
+    xval, yval, zval = (prop.values for prop in grid.get_xyz())
+
+    if filter_array is not None:
+        if filter_array.shape != grid.dimensions:
+            raise ValueError(
+                "The filter_array needs to have the same dimensions as the grid. "
+                f"Found: {filter_array.shape=} {grid.dimensions=}"
+            )
+        xval = np.ma.masked_where(~filter_array, xval)
+        yval = np.ma.masked_where(~filter_array, yval)
+        zval = np.ma.masked_where(~filter_array, zval)
+
+    # for performance create average points along layers
+    xval = np.ma.mean(xval, axis=2)
+    yval = np.ma.mean(yval, axis=2)
+    zval = np.ma.mean(zval, axis=2)
+
+    xyz_values = np.column_stack(
+        (
+            xval[~xval.mask].ravel(),
+            yval[~yval.mask].ravel(),
+            zval[~zval.mask].ravel(),
+        )
+    )
+
+    pol = Polygons.boundary_from_points(
+        points=Points(xyz_values),
+        alpha_factor=alpha_factor,
+        alpha=_estimate_alpha_for_grid(grid),
+        convex=convex,
+    )
+
+    if simplify:
+        if isinstance(simplify, bool):
+            pol.simplify(tolerance=0.1)
+        elif isinstance(simplify, dict) and "tolerance" in simplify:
+            pol.simplify(**simplify)
+        else:
+            raise ValueError("Invalid values for simplify keyword")
+
+    return pol
+
+
+def _estimate_alpha_for_grid(grid: Grid) -> float:
+    """
+    Estimate an alpha based on grid resolution.
+    Max dx and dy is used as basis for calculation to ensure that the alpha
+    computed is always high enough to prevent polygons appearing around areas
+    of the grid where cells have larger than average dx/dy increments.
+    """
+    dx, dy = grid.get_dx(), grid.get_dy()
+    xinc, yinc = dx.values.max(), dy.values.max()
+    return math.ceil(math.sqrt(xinc**2 + yinc**2) / 2)