xtgeo 4.12.0__cp313-cp313-win_amd64.whl → 4.13.0__cp313-cp313-win_amd64.whl

xtgeo/common/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.12.0'
-__version_tuple__ = version_tuple = (4, 12, 0)
+__version__ = version = '4.13.0'
+__version_tuple__ = version_tuple = (4, 13, 0)
 
-__commit_id__ = commit_id = 'g4f136d221'
+__commit_id__ = commit_id = 'g766805bb7'

xtgeo/cube/_cube_window_attributes.py

@@ -7,7 +7,6 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Final
 
 import numpy as np
-from scipy.interpolate import make_interp_spline
 
 import xtgeo._internal as _internal  # type: ignore
 from xtgeo.common.log import null_logger
@@ -42,7 +41,13 @@ SUM_ATTRS: Final = [
 
 @dataclass
 class CubeAttrs:
-    """Internal class for computing attributes in window between two surfaces."""
+    """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
@@ -55,6 +60,8 @@ class CubeAttrs:
     _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
@@ -70,9 +77,7 @@ class CubeAttrs:
     def __post_init__(self) -> None:
         self._process_upper_lower_surface()
         self._create_depth_array()
-        self._create_reduced_cube()
-        self._refine_interpolate()
-        self._depth_mask()
+        self._determine_slice_indices()
         self._compute_statistical_attribute_surfaces()
 
     def result(self) -> dict[RegularSurface]:
@@ -84,6 +89,8 @@ class CubeAttrs:
 
         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))
@@ -132,6 +139,7 @@ class CubeAttrs:
                 "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.
@@ -142,6 +150,7 @@ class CubeAttrs:
         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(
             [
@@ -175,18 +184,16 @@ class CubeAttrs:
             self._outside_depth,
             self._depth_array,
         )
+        logger.debug("Create depth array... done")
 
-    def _create_reduced_cube(self) -> None:
-        """Create a smaller cube based on the depth cube filter.
+    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.
         """
-        from xtgeo import Cube  # avoid circular import by having this here
-
-        cubev = self.cube.values.copy()  # copy, so we don't change the input instance
-        cubev[self.cube.traceidcodes == 2] = 0.0  # set traceidcode 2 to zero
+        logger.debug("Determine cube slice indices...")
 
         # Create a boolean mask based on the threshold
         mask = self._depth_array < self._outside_depth
@@ -200,124 +207,21 @@ class CubeAttrs:
                 "outside the cube?"
             )
 
-        min_indices = np.min(non_zero_indices)
-        max_indices = np.max(non_zero_indices) + 1  # Add 1 to include the upper bound
-
-        # Extract the reduced cube using slicing
-        reduced = cubev[:, :, min_indices:max_indices]
-
-        zori = float(self._depth_array.min())
-
-        self._reduced_cube = Cube(
-            ncol=reduced.shape[0],
-            nrow=reduced.shape[1],
-            nlay=reduced.shape[2],
-            xinc=self.cube.xinc,
-            yinc=self.cube.yinc,
-            zinc=self.cube.zinc,
-            xori=self.cube.xori,
-            yori=self.cube.yori,
-            zori=zori,
-            rotation=self.cube.rotation,
-            yflip=self.cube.yflip,
-            values=reduced.astype(np.float32),
-        )
-
-        self._reduced_depth_array = self._depth_array[min_indices:max_indices]
-
-        logger.debug("Reduced cubes created %s", self._reduced_cube.values.shape)
-
-    def _refine_interpolate(self) -> None:
-        """Apply reduced cubes and interpolate to a finer grid vertically.
+        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)
 
-        This is done to get a more accurate representation of the cube values.
-        """
-        from xtgeo import Cube
-
-        logger.debug("Refine cubes and interpolate...")
-        arr = self._reduced_cube.values
-        ndiv = self.ndiv
-
-        # Create linear interpolation function along the last axis
-        fdepth = make_interp_spline(
-            np.arange(arr.shape[2]),
-            self._reduced_depth_array,
-            axis=0,
-            k=1,
-        )
-
-        # Create interpolation function along the last axis
-        if self.interpolation not in ["cubic", "linear"]:
-            raise ValueError("Interpolation must be either 'cubic' or 'linear'")
-
-        fcube = make_interp_spline(
-            np.arange(arr.shape[2]),
-            arr,
-            axis=2,
-            k=3 if self.interpolation == "cubic" else 1,
+        logger.debug("Determine cube slice indices... done")
+        logger.debug(
+            "Cube slice indices: %d to %d", self._min_indices, self._max_indices
         )
-        # Define new sampling points along the last axis
-        new_z = np.linspace(0, arr.shape[2] - 1, arr.shape[2] * ndiv)
-
-        # Resample the cube array
-        resampled_arr = fcube(new_z)
-
-        # Resample the depth array (always linear)
-        self._refined_depth_array = new_depth = fdepth(new_z)
-        new_zinc = (new_depth.max() - new_depth.min()) / (new_depth.shape[0] - 1)
-
-        self._refined_cube = Cube(
-            ncol=resampled_arr.shape[0],
-            nrow=resampled_arr.shape[1],
-            nlay=resampled_arr.shape[2],
-            xinc=self.cube.xinc,
-            yinc=self.cube.yinc,
-            zinc=new_zinc,
-            xori=self.cube.xori,
-            yori=self.cube.yori,
-            zori=self._refined_depth_array.min(),
-            rotation=self._reduced_cube.rotation,
-            yflip=self._reduced_cube.yflip,
-            values=resampled_arr.astype(np.float32),
-        )
-
-    def _depth_mask(self) -> None:
-        """Set nan values outside the interval defined by the upper + lower surface.
-
-        In addition, set nan values where the thickness is less than the minimum.
-
-        """
-
-        darry = np.expand_dims(self._refined_depth_array, axis=(0, 1))
-        upper_exp = np.expand_dims(self._upper.values, 2)
-        lower_exp = np.expand_dims(self._lower.values, 2)
-        mask_2d_exp = np.expand_dims(self._min_thickness_mask.values, 2)
-
-        self._refined_cube.values = np.where(
-            (darry < upper_exp) | (darry > lower_exp) | (mask_2d_exp == 0),
-            np.nan,
-            self._refined_cube.values,
-        ).astype(np.float32)
-
-        # similar for reduced cubes with original resolution
-        darry = np.expand_dims(self._reduced_depth_array, axis=(0, 1))
-
-        self._reduced_cube.values = np.where(
-            (darry < upper_exp) | (darry > lower_exp) | (mask_2d_exp == 0),
-            np.nan,
-            self._reduced_cube.values,
-        ).astype(np.float32)
 
     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)
 
-        # apply mask for the cube's dead traces (traceidcode 2)
-        attr_map.values = np.ma.masked_where(
-            self.cube.traceidcodes == 2, attr_map.values
-        )
-
         # now resample to the original input map
         attr_map_resampled = self._template_surface.copy()
         attr_map_resampled.resample(attr_map)
@@ -329,21 +233,41 @@ class CubeAttrs:
             )
 
         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."""
-
-        # compute statistics for vertically refined cube
-        cubecpp = _internal.cube.Cube(self._refined_cube)
-        all_attrs = cubecpp.cube_stats_along_z()
+        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 for reduced cube (for sum attributes)
-        cubecpp = _internal.cube.Cube(self._reduced_cube)
-        all_attrs = cubecpp.cube_stats_along_z()
+        # 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,
+        )
 
-        # add sum attributes which are the last 3 in the list
         for attr in SUM_ATTRS:
             self._add_to_attribute_map(attr, all_attrs[attr])
+
+        logger.debug("Compute statistical attribute surfaces... done")

xtgeo/grid3d/_ecl_inte_head.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
-import warnings
 from typing import Any, Literal, cast
 
 import numpy as np
 import numpy.typing as npt
 
+from xtgeo.common.log import null_logger
+
 from ._ecl_output_file import Phases, Simulator, TypeOfGrid, UnitSystem
 
+_logger = null_logger(__name__)
+
 
 class InteHead:
     """Contains the values for the INTEHEAD array in ecl restart
@@ -134,7 +137,8 @@ class InteHead:
         try:
             return Simulator(s_code)
         except ValueError:
-            warnings.warn(f"Unknown simulator code {s_code}")
+            # changed from a UserWarning to a logging message
+            _logger.warning("Unknown simulator code %s", s_code)
             return s_code
 
     @property

xtgeo/grid3d/_grid_etc1.py

@@ -193,7 +193,8 @@ def get_dz(
     if not flip:
         result *= -1
 
-    result = np.ma.masked_array(result, self._actnumsv == 0 if asmasked else False)
+    if asmasked:
+        result = np.ma.masked_array(result, self._actnumsv == 0)
 
     return GridProperty(
         ncol=self._ncol,
@@ -1399,7 +1400,10 @@ def estimate_design(
     """Estimate (guess) (sub)grid design by examing DZ in median thickness column."""
     actv = self.get_actnum().values
 
-    dzv = self.get_dz(asmasked=False).values
+    dzv_raw = self.get_dz(asmasked=False).values
+    # Although asmasked is False the array values will still be a masked numpy
+    # Need to convert to an ordinary numpy to avoid warnings later
+    dzv = np.ma.filled(dzv_raw, fill_value=0.0)
 
     # treat inactive thicknesses as zero
     dzv[actv == 0] = 0.0
@@ -1416,6 +1420,11 @@ def estimate_design(
     # find cumulative thickness as a 2D array
     dzcum: np.ndarray = np.sum(dzv, axis=2, keepdims=False)
 
+    # Ensure dzcum is a regular numpy array to avoid warnings
+    if isinstance(dzcum, np.ma.MaskedArray):
+        dzcum = np.ma.filled(dzcum, fill_value=0.0)
+    dzcum = np.asarray(dzcum)
+
     # find the average thickness for nonzero thicknesses
     dzcum2 = dzcum.copy()
     dzcum2[dzcum == 0.0] = np.nan

xtgeo/grid3d/_grid_hybrid.py

@@ -4,9 +4,8 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
-from xtgeo import _cxtgeo
+import xtgeo._internal as _internal  # type: ignore
 from xtgeo.common import null_logger
-from xtgeo.common.constants import UNDEF_INT
 
 logger = null_logger(__name__)
 
@@ -23,44 +22,29 @@ def make_hybridgrid(
     region_number: int | None = None,
 ) -> None:
     """Make hybrid grid."""
-    self._set_xtgformat1()
+    self._set_xtgformat2()
 
     newnlay = self.nlay * 2 + nhdiv
-    newnzcorn = self.ncol * self.nrow * (newnlay + 1) * 4
-    newnactnum = self.ncol * self.nrow * newnlay
 
-    # initialize
-    hyb_zcornsv = np.zeros(newnzcorn, dtype=np.float64)
-    hyb_actnumsv = np.zeros(newnactnum, dtype=np.int32)
-
-    if region is None:
-        region_number = -1
-        rvalues = np.ones(1, dtype=np.int32)
-    else:
-        rvalues = np.ma.filled(region.values, fill_value=UNDEF_INT)
-        rvalues = rvalues.ravel()
-
-    _cxtgeo.grd3d_convert_hybrid(
-        self.ncol,
-        self.nrow,
-        self.nlay,
-        self._coordsv,
-        self._zcornsv,
-        self._actnumsv,
-        newnlay,
-        hyb_zcornsv,
-        hyb_actnumsv,
+    grid3d_cpp = _internal.grid3d.Grid(self)
+    region_array = (
+        region.values.astype(np.int32)
+        if region
+        else np.empty((0, 0, 0), dtype=np.int32)
+    )
+    hyb_zcornsv, hyb_actnumsv = grid3d_cpp.convert_to_hybrid_grid(
         toplevel,
         bottomlevel,
         nhdiv,
-        rvalues,
-        region_number,
+        region_array,
+        int(region_number) if region_number is not None else -1,
     )
 
     # when a hybridgrid is made, the current subrid settings lose relevance, hence
     # it is forced set to None
     self.subgrids = None
 
+    # update the grid in place
     self._nlay = newnlay
     self._zcornsv = hyb_zcornsv
-    self._actnumsv = hyb_actnumsv
+    self._actnumsv = hyb_actnumsv.astype(np.int32)

xtgeo/grid3d/_grid_refine.py

@@ -243,7 +243,7 @@ def refine_vertically(
     # update instance:
     self._nlay = newnlay
     self._zcornsv = ref_zcornsv
-    self._actnumsv = ref_actnumsv
+    self._actnumsv = ref_actnumsv.astype(np.int32)
 
     if self.subgrids is None or len(self.subgrids) <= 1:
         self.subgrids = None

xtgeo/grid3d/_gridprop_roxapi.py

@@ -150,12 +150,18 @@ def _validate_dtype_in_roxar(
         )
 
     try:
+        # for mypy
+        min_val: int | float
+        max_val: int | float
+
         if np.issubdtype(dtype, np.integer):
             # Integer type
-            min_val, max_val = np.iinfo(dtype).min, np.iinfo(dtype).max
+            min_val = int(np.iinfo(dtype).min)
+            max_val = int(np.iinfo(dtype).max)
         elif np.issubdtype(dtype, np.floating):
             # Float type
-            min_val, max_val = np.finfo(dtype).min, np.finfo(dtype).max
+            min_val = float(np.finfo(dtype).min)
+            max_val = float(np.finfo(dtype).max)
         else:
             # Unknown type
             raise RuntimeError("Probable bug, values array not integer or float")

xtgeo/grid3d/grid.py

@@ -1818,7 +1818,9 @@ class Grid(_Grid3D):
             name (str): name of property
             flip (bool): Use False for Petrel grids were Z is negative down
                 (experimental)
-            asmasked (bool): True if only for active cells, False for all cells
+            asmasked (bool): True if only for active cells, False for all cells.
+                With `False` the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -1854,7 +1856,8 @@ class Grid(_Grid3D):
         Args:
             name (str): names of properties
             asmasked (bool). If True, make a np.ma array where inactive cells
-                are masked.
+                are masked. Otherwise the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -1884,7 +1887,8 @@ class Grid(_Grid3D):
         Args:
             name (str): names of properties
             asmasked (bool). If True, make a np.ma array where inactive cells
-                are masked.
+                are masked. Otherwise the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -2556,11 +2560,13 @@ class Grid(_Grid3D):
            :align: center
 
         Args:
-            nhdiv (int): Number of hybrid layers.
-            toplevel (float): Top of hybrid grid.
-            bottomlevel (float): Base of hybrid grid.
-            region (GridProperty, optional): Region property (if needed).
-            region_number (int): Which region to apply hybrid grid in if region.
+            nhdiv: Number of hybrid layers.
+            toplevel: Top of hybrid grid.
+            bottomlevel: Base of hybrid grid.
+            region: Region property (if needed). Note that the region will only be
+                applied in a lateral sense: i.e. if a column is in the region, then
+                the full column will be converted to hybrid.
+            region_number: Which region to apply hybrid grid in if region.
 
         Example:
             Create a hybridgrid from file, based on a GRDECL file (no region)::
@@ -2577,6 +2583,7 @@ class Grid(_Grid3D):
         .. _usage in the Troll field: https://doi.org/10.2118/148023-MS
 
         """
+
         _grid_hybrid.make_hybridgrid(
             self,
             nhdiv=nhdiv,

xtgeo/surface/_regsurf_oper.py

@@ -448,99 +448,6 @@ def _get_randomline_fence(self, fencespec, hincrement, atleast, nextend):
     return fspec
 
 
-def operation_polygons(self, poly, value, opname="add", inside=True):
-    """Operations restricted to polygons"""
-
-    # keep this for a while (e.g. mid 2024), and then replace it with _v2 below.
-    if not isinstance(poly, Polygons):
-        raise ValueError("The poly input is not a Polygons instance")
-    if opname not in VALID_OPER_POLYS:
-        raise ValueError(f"Operation key opname has invalid value: {opname}")
-
-    # make a copy of the RegularSurface which is used a "filter" or "proxy"
-    # value will be 1 inside polygons, 0 outside. Undef cells are kept as is
-
-    proxy = self.copy()
-    proxy.values *= 0.0
-    vals = proxy.get_values1d(fill_value=UNDEF)
-
-    # value could be a scalar or another surface; if another surface,
-    # must ensure same topology
-
-    if isinstance(value, type(self)):
-        if not self.compare_topology(value):
-            raise ValueError("Input is RegularSurface, but not same map topology")
-        value = value.values.copy()
-    else:
-        # turn scalar value into numpy array
-        value = self.values.copy() * 0 + value
-
-    idgroups = poly.get_dataframe(copy=False).groupby(poly.pname)
-
-    for _, grp in idgroups:
-        xcor = grp[poly.xname].values
-        ycor = grp[poly.yname].values
-
-        ier = _cxtgeo.surf_setval_poly(
-            proxy.xori,
-            proxy.xinc,
-            proxy.yori,
-            proxy.yinc,
-            proxy.ncol,
-            proxy.nrow,
-            proxy.yflip,
-            proxy.rotation,
-            vals,
-            xcor,
-            ycor,
-            1.0,
-            0,
-        )
-        if ier == -9:
-            xtg.warn("Polygon is not closed")
-
-    proxy.set_values1d(vals)
-    proxyv = proxy.values.astype(np.int8)
-
-    proxytarget = 1
-    if not inside:
-        proxytarget = 0
-
-    tmp = None
-    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 0.0 in value:
-            xtg.warn(
-                "Dividing a surface with value=0.0 or surface with zero "
-                "elements; may get unexpected results, try to "
-                "achieve zero values as result!"
-            )
-        with np.errstate(divide="ignore", invalid="ignore"):
-            this = ma.filled(self.values, fill_value=1.0)
-            that = ma.filled(value, fill_value=1.0)
-            mask = 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 = ma.array(tmp, mask=mask)
-
-    elif opname == "set":
-        tmp = value
-    elif opname == "eli":
-        tmp = value * 0 + UNDEF
-        tmp = ma.masked_greater(tmp, UNDEF_LIMIT)
-
-    self.values[proxyv == proxytarget] = tmp[proxyv == proxytarget]
-    del tmp
-
-
 def _proxy_map_polygons(surf, poly, inside=True):
     """Return a proxy map where on one to do operations, as 0 and 1."""
     inside_value = 1 if inside else 0
@@ -574,7 +481,7 @@ def _proxy_map_polygons(surf, poly, inside=True):
     return proxy
 
 
-def operation_polygons_v2(self, poly, value: float | Any, opname="add", inside=True):
+def operation_polygons(self, poly, value: float | Any, opname="add", inside=True):
     """Operations restricted to polygons, using matplotlib (much faster).
 
     The 'value' can be a number or another regular surface (with same design)

xtgeo/surface/regular_surface.py

@@ -1883,7 +1883,7 @@ class RegularSurface:
     # Operations restricted to inside/outside polygons
     # ==================================================================================
 
-    def operation_polygons(self, poly, value, opname="add", inside=True, _version=2):
+    def operation_polygons(self, poly, value, opname="add", inside=True):
         """A generic function for map operations inside or outside polygon(s).
 
         Args:
@@ -1895,14 +1895,9 @@ class RegularSurface:
                 on polygons (this key will be removed in later versions and shall not
                 be applied)
         """
-        if _version == 2:
-            _regsurf_oper.operation_polygons_v2(
-                self, poly, value, opname=opname, inside=inside
-            )
-        else:
-            _regsurf_oper.operation_polygons(
-                self, poly, value, opname=opname, inside=inside
-            )
+        _regsurf_oper.operation_polygons(
+            self, poly, value, opname=opname, inside=inside
+        )
 
     # shortforms
     def add_inside(self, poly, value):