xtgeo 4.14.1__cp313-cp313-win_amd64.whl

xtgeo/cube/_cube_utils.py

@@ -0,0 +1,287 @@
+"""Cube utilities (basic low level)"""
+
+import warnings
+
+import numpy as np
+
+from xtgeo import _cxtgeo
+from xtgeo._cxtgeo import XTGeoCLibError
+from xtgeo.common.calc import _swap_axes
+from xtgeo.common.constants import UNDEF_LIMIT
+from xtgeo.common.log import null_logger
+from xtgeo.xyz.polygons import Polygons
+
+logger = null_logger(__name__)
+
+
+def swapaxes(self):
+    """Pure numpy/python version"""
+    self._rotation, self._yflip, swapped_values = _swap_axes(
+        self._rotation,
+        self._yflip,
+        values=self._values,
+        traceidcodes=self._traceidcodes,
+    )
+    self._ncol, self._nrow = self._nrow, self._ncol
+    self._xinc, self._yinc = self._yinc, self._xinc
+    self.values = swapped_values["values"]
+    self._traceidcodes = swapped_values["traceidcodes"]
+
+
+def thinning(self, icol, jrow, klay):
+    inputs = [icol, jrow, klay]
+    ranges = [self.nrow, self.ncol, self.nlay]
+
+    for inum, ixc in enumerate(inputs):
+        if not isinstance(ixc, int):
+            raise ValueError(f"Some input is not integer: {inputs}")
+        if ixc > ranges[inum] / 2:
+            raise ValueError(
+                f"Input numbers <{inputs}> are too large compared to existing "
+                f"ranges <{ranges}>"
+            )
+
+    # just simple numpy operations, and changing some cube props
+
+    val = self.values.copy()
+
+    val = val[::icol, ::jrow, ::klay]
+    self._ncol = val.shape[0]
+    self._nrow = val.shape[1]
+    self._nlay = val.shape[2]
+    self._xinc *= icol
+    self._yinc *= jrow
+    self._zinc *= klay
+    self._ilines = self._ilines[::icol]
+    self._xlines = self._xlines[::jrow]
+    self._traceidcodes = self._traceidcodes[::icol, ::jrow]
+
+    self.values = val
+
+
+def cropping(self, icols, jrows, klays):
+    """Cropping, where inputs are tuples"""
+
+    icol1, icol2 = icols
+    jrow1, jrow2 = jrows
+    klay1, klay2 = klays
+
+    val = self.values.copy()
+    ncol = self.ncol
+    nrow = self.nrow
+    nlay = self.nlay
+
+    val = val[
+        0 + icol1 : ncol - icol2, 0 + jrow1 : nrow - jrow2, 0 + klay1 : nlay - klay2
+    ]
+
+    self._ncol = val.shape[0]
+    self._nrow = val.shape[1]
+    self._nlay = val.shape[2]
+
+    self._ilines = self._ilines[0 + icol1 : ncol - icol2]
+    self._xlines = self._xlines[0 + jrow1 : nrow - jrow2]
+    self.traceidcodes = self.traceidcodes[
+        0 + icol1 : ncol - icol2, 0 + jrow1 : nrow - jrow2
+    ]
+
+    # 1 + .., since the following routine as 1 as base for i j
+    ier, xpp, ypp = _cxtgeo.cube_xy_from_ij(
+        1 + icol1,
+        1 + jrow1,
+        self.xori,
+        self.xinc,
+        self.yori,
+        self.yinc,
+        ncol,
+        nrow,
+        self.yflip,
+        self.rotation,
+        0,
+    )
+
+    if ier != 0:
+        raise RuntimeError(f"Unexpected error, code is {ier}")
+
+    # get new X Y origins
+    self._xori = xpp
+    self._yori = ypp
+    self._zori = self.zori + klay1 * self.zinc
+
+    self.values = val
+
+
+def resample(self, other, sampling="nearest", outside_value=None):
+    """Resample another cube to the current self"""
+    # TODO: traceidcodes
+
+    values1a = self.values.reshape(-1)
+    values2a = other.values.reshape(-1)
+
+    logger.info("Resampling, using %s...", sampling)
+
+    ier = _cxtgeo.cube_resample_cube(
+        self.ncol,
+        self.nrow,
+        self.nlay,
+        self.xori,
+        self.xinc,
+        self.yori,
+        self.yinc,
+        self.zori,
+        self.zinc,
+        self.rotation,
+        self.yflip,
+        values1a,
+        other.ncol,
+        other.nrow,
+        other.nlay,
+        other.xori,
+        other.xinc,
+        other.yori,
+        other.yinc,
+        other.zori,
+        other.zinc,
+        other.rotation,
+        other.yflip,
+        values2a,
+        1 if sampling == "trilinear" else 0,
+        0 if outside_value is None else 1,
+        0 if outside_value is None else outside_value,
+    )
+    if ier == -4:
+        warnings.warn("Less than 10% of origonal cube sampled", RuntimeWarning)
+    elif ier != 0:
+        raise XTGeoCLibError("cube_resample_cube failed to complete")
+
+
+def get_xy_value_from_ij(self, iloc, jloc, ixline=False, zerobased=False):
+    """Find X Y value from I J index, or corresponding inline/xline"""
+    # assumes that inline follows I and xlines follows J
+
+    iuse = iloc
+    juse = jloc
+
+    if zerobased:
+        iuse = iuse + 1
+        juse = juse + 1
+
+    if ixline:
+        ilst = self.ilines.tolist()
+        jlst = self.xlines.tolist()
+        iuse = ilst.index(iloc) + 1
+        juse = jlst.index(jloc) + 1
+
+    if 1 <= iuse <= self.ncol and 1 <= juse <= self.nrow:
+        ier, xval, yval = _cxtgeo.cube_xy_from_ij(
+            iuse,
+            juse,
+            self.xori,
+            self.xinc,
+            self.yori,
+            self.yinc,
+            self.ncol,
+            self.nrow,
+            self._yflip,
+            self.rotation,
+            0,
+        )
+        if ier != 0:
+            raise XTGeoCLibError(f"cube_xy_from_ij failed with error code: {ier}")
+
+    else:
+        raise ValueError("Index i and/or j out of bounds")
+
+    return xval, yval
+
+
+def get_randomline(
+    self,
+    fencespec,
+    zmin=None,
+    zmax=None,
+    zincrement=None,
+    hincrement=None,
+    atleast=5,
+    nextend=2,
+    sampling="nearest",
+):
+    """Get a random line from a fence spesification"""
+
+    if isinstance(fencespec, Polygons):
+        logger.info("Estimate hincrement from Polygons instance...")
+        fencespec = _get_randomline_fence(self, fencespec, hincrement, atleast, nextend)
+        logger.info("Estimate hincrement from Polygons instance... DONE")
+
+    if not len(fencespec.shape) == 2:
+        raise ValueError("Fence is not a 2D numpy")
+
+    xcoords = fencespec[:, 0]
+    ycoords = fencespec[:, 1]
+    hcoords = fencespec[:, 3]
+
+    for ino in range(hcoords.shape[0] - 1):
+        dhv = hcoords[ino + 1] - hcoords[ino]
+        logger.info("Delta H along well path: %s", dhv)
+
+    zcubemax = self._zori + (self._nlay - 1) * self._zinc
+    if zmin is None or zmin < self._zori:
+        zmin = self._zori
+
+    if zmax is None or zmax > zcubemax:
+        zmax = zcubemax
+
+    if zincrement is None:
+        zincrement = self._zinc / 2.0
+
+    nzsam = int((zmax - zmin) / zincrement) + 1
+
+    nsamples = xcoords.shape[0] * nzsam
+
+    option = 0
+    if sampling == "trilinear":
+        option = 1
+
+    _ier, values = _cxtgeo.cube_get_randomline(
+        xcoords,
+        ycoords,
+        zmin,
+        zmax,
+        nzsam,
+        self._xori,
+        self._xinc,
+        self._yori,
+        self._yinc,
+        self._zori,
+        self._zinc,
+        self._rotation,
+        self._yflip,
+        self._ncol,
+        self._nrow,
+        self._nlay,
+        self._values.reshape(-1),
+        nsamples,
+        option,
+    )
+
+    values[values > UNDEF_LIMIT] = np.nan
+    arr = values.reshape((xcoords.shape[0], nzsam)).T
+
+    return (hcoords[0], hcoords[-1], zmin, zmax, arr)
+
+
+def _get_randomline_fence(self, fencespec, hincrement, atleast, nextend):
+    """Compute a resampled fence from a Polygons instance"""
+
+    if hincrement is None:
+        avgdxdy = 0.5 * (self.xinc + self.yinc)
+        distance = 0.5 * avgdxdy
+    else:
+        distance = hincrement
+
+    logger.info("Getting fence from a Polygons instance...")
+    fspec = fencespec.get_fence(
+        distance=distance, atleast=atleast, nextend=nextend, asnumpy=True
+    )
+    logger.info("Getting fence from a Polygons instance... DONE")
+    return fspec

xtgeo/cube/_cube_window_attributes.py

@@ -0,0 +1,273 @@
+"""Attributes for a Cube to maps (surfaces), slice an interval, in pure numpy."""
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Final
+
+import numpy as np
+
+import xtgeo._internal as _internal  # type: ignore
+from xtgeo.common.log import null_logger
+
+if TYPE_CHECKING:
+    from xtgeo.surface.regular_surface import RegularSurface
+
+    from . import Cube
+
+logger = null_logger(__name__)
+
+
+STAT_ATTRS: Final = [
+    "min",
+    "max",
+    "mean",
+    "var",
+    "rms",
+    "maxpos",
+    "maxneg",
+    "maxabs",
+    "meanpos",
+    "meanneg",
+    "meanabs",
+]
+SUM_ATTRS: Final = [
+    "sumpos",
+    "sumneg",
+    "sumabs",
+]
+
+
+@dataclass
+class CubeAttrs:
+    """Internal class for computing attributes in window between two surfaces.
+
+    Compared with the former implementation (mid September 2025), more logic is moved
+    to the C++ routine, ensuring:
+    - Significantly smaller memory overhead (e.g. 0.1 GB vs 20 GB)
+    - Much faster execution, in particularly when using multiple processers. (5-10 x)
+    """
+
+    cube: Cube
+    upper_surface: RegularSurface | float | int
+    lower_surface: RegularSurface | float | int
+    ndiv: int = 10
+    interpolation: str = "cubic"  # cf. scipy's make_interp_spline() when k=3
+    minimum_thickness: float = 0.0
+
+    # internal attributes
+    _template_surface: RegularSurface | None = None
+    _depth_array: np.ndarray | None = None
+    _outside_depth: float | None = None  # detected and updated from the depth cube
+    _min_indices: int = 0  # minimum Z index for cube slicing
+    _max_indices: int = 0  # maximum Z index for cube slicing
+    _reduced_cube: Cube = None
+    _reduced_depth_array: np.ndarray | None = None
+    _refined_cube: Cube | None = None
+    _refined_depth_array: np.ndarray | None = None
+
+    _upper: RegularSurface | None = None  # upper surf, resampled to cube map resolution
+    _lower: RegularSurface | None = None  # lower surf, resampled to cube map resolution
+    _min_thickness_mask: RegularSurface | None = None  # mask for min. thickness trunc.
+    _mask_map_by_traceidcode: RegularSurface | None = None  # mask for traceidcode 2
+
+    _result_attr_maps: dict = field(default_factory=dict)  # holds the resulting maps
+
+    def __post_init__(self) -> None:
+        self._process_upper_lower_surface()
+        self._create_depth_array()
+        self._determine_slice_indices()
+        self._compute_statistical_attribute_surfaces()
+
+    def result(self) -> dict[RegularSurface]:
+        # return the resulting attribute maps
+        return self._result_attr_maps
+
+    def _process_upper_lower_surface(self) -> None:
+        """Extract upper and lower surface, sampled to cube resolution."""
+
+        from xtgeo import surface_from_cube  # avoid circular import by having this here
+
+        logger.debug("Process upper and lower surface...")
+
+        upper = (
+            surface_from_cube(self.cube, self.upper_surface)
+            if isinstance(self.upper_surface, (float, int))
+            else self.upper_surface
+        )
+        lower = (
+            surface_from_cube(self.cube, self.lower_surface)
+            if isinstance(self.lower_surface, (float, int))
+            else self.lower_surface
+        )
+
+        # the template surface is the topology that defines the resulting attribute maps
+        self._template_surface = (
+            upper
+            if isinstance(self.upper_surface, (float, int))
+            else self.upper_surface
+        )
+
+        # determine which of "this" and "other" is actually upper and lower
+        if (lower - upper).values.mean() < 0:
+            raise ValueError(
+                "The upper surface is below the lower surface. "
+                "Please provide the surfaces in the correct order."
+            )
+
+        # although not an attribute, we store the upper and lower surfaces
+        self._result_attr_maps["upper"] = upper
+        self._result_attr_maps["lower"] = lower
+
+        # get the surfaces on cube resolution
+        self._upper = surface_from_cube(self.cube, self.cube.zori)
+        self._lower = surface_from_cube(self.cube, self.cube.zori)
+        self._upper.resample(upper)
+        self._lower.resample(lower)
+
+        self._upper.fill()
+        self._lower.fill()
+
+        self._min_thickness_mask = self._lower - self._upper
+
+        self._min_thickness_mask.values = np.where(
+            self._min_thickness_mask.values <= self.minimum_thickness, 0, 1
+        )
+        if np.all(self._min_thickness_mask.values == 0):
+            raise ValueError(
+                "The minimum thickness is too large, no valid data in the interval. "
+                "Perhaps surfaces are overlapping?"
+            )
+        logger.debug("Process upper and lower surface... done")
+
+    def _create_depth_array(self) -> None:
+        """Create a 1D array where values are cube depths; to be used as filter.
+
+        Belowe and above the input surfaces (plus a buffer), the values are set to
+        a constant value self._outside_depth.
+
+        Will also issue warnings or errors if the surfaces are outside the cube,
+        depending on severity.
+        """
+        logger.debug("Create depth array...")
+
+        self._depth_array = np.array(
+            [
+                self.cube.zori + n * self.cube.zinc
+                for n in range(self.cube.values.shape[2])
+            ]
+        ).astype(np.float32)
+
+        # check that surfaces are within the cube
+        if self._upper.values.min() > self._depth_array.max():
+            raise ValueError("Upper surface is fully below the cube")
+        if self._lower.values.max() < self._depth_array.min():
+            raise ValueError("Lower surface is fully above the cube")
+        if self._upper.values.max() < self._depth_array.min():
+            warnings.warn("Upper surface is fully above the cube", UserWarning)
+        if self._lower.values.min() > self._depth_array.max():
+            warnings.warn("Lower surface is fully below the cube", UserWarning)
+
+        self._outside_depth = self._depth_array.max() + 1
+
+        add_extra_depth = 2 * self.cube.zinc  # add buffer on upper/lower edges
+
+        self._depth_array = np.where(
+            self._depth_array < self._upper.values.min() - add_extra_depth,
+            self._outside_depth,
+            self._depth_array,
+        )
+
+        self._depth_array = np.where(
+            self._depth_array > self._lower.values.max() + add_extra_depth,
+            self._outside_depth,
+            self._depth_array,
+        )
+        logger.debug("Create depth array... done")
+
+    def _determine_slice_indices(self) -> None:
+        """Create parameters for cube slicing.
+
+        The purpose is to limit the computation to the relevant volume, to save
+        CPU time. I.e. cube values above the upper surface and below the lower are
+        now excluded.
+        """
+        logger.debug("Determine cube slice indices...")
+
+        # Create a boolean mask based on the threshold
+        mask = self._depth_array < self._outside_depth
+
+        # Find the bounding box of the true values
+        non_zero_indices = np.nonzero(mask)[0]
+
+        if len(non_zero_indices) == 0:
+            raise RuntimeError(  # e.g. if cube and surfaces are at different locations
+                "No valid data found in the depth cube. Perhaps the surfaces are "
+                "outside the cube?"
+            )
+
+        self._min_indices = int(np.min(non_zero_indices))
+        # Add 1 to include the upper bound
+        self._max_indices = int(np.max(non_zero_indices) + 1)
+
+        logger.debug("Determine cube slice indices... done")
+        logger.debug(
+            "Cube slice indices: %d to %d", self._min_indices, self._max_indices
+        )
+
+    def _add_to_attribute_map(self, attr_name: str, values: np.ndarray) -> None:
+        """Compute the attribute map and add to result dictionary."""
+        logger.debug("Add to attribute map...")
+        attr_map = self._upper.copy()
+        attr_map.values = np.ma.masked_invalid(values)
+
+        # now resample to the original input map
+        attr_map_resampled = self._template_surface.copy()
+        attr_map_resampled.resample(attr_map)
+
+        # Use template_surface consistently for masking (it's already set correctly)
+        if hasattr(self._template_surface.values, "mask"):
+            attr_map_resampled.values = np.ma.masked_where(
+                self._template_surface.values.mask, attr_map_resampled.values
+            )
+
+        self._result_attr_maps[attr_name] = attr_map_resampled
+        logger.debug("Add to attribute map... done")
+
+    def _compute_statistical_attribute_surfaces(self) -> None:
+        """Compute stats very fast by using internal C++ bindings."""
+        logger.debug("Compute statistical attribute surfaces...")
+
+        # compute statistics for vertically refined cube using original cube
+        cubecpp = _internal.cube.Cube(self.cube)
+        all_attrs = cubecpp.cube_stats_along_z(
+            self._upper.values,
+            self._lower.values,
+            self._depth_array,  # use original depth array
+            self.ndiv,
+            self.interpolation,
+            self.minimum_thickness,
+            self._min_indices,  # pass slice indices
+            self._max_indices,
+        )
+
+        for attr in STAT_ATTRS:
+            self._add_to_attribute_map(attr, all_attrs[attr])
+
+        # compute statistics with ndiv=1 (for sum attributes)
+        all_attrs = cubecpp.cube_stats_along_z(
+            self._upper.values,
+            self._lower.values,
+            self._depth_array,  # use original depth array
+            1,
+            self.interpolation,
+            self.minimum_thickness,
+            self._min_indices,  # pass slice indices
+            self._max_indices,
+        )
+
+        for attr in SUM_ATTRS:
+            self._add_to_attribute_map(attr, all_attrs[attr])
+
+        logger.debug("Compute statistical attribute surfaces... done")