xtgeo 4.12.1__cp313-cp313-macosx_11_0_arm64.whl → 4.13.1__cp313-cp313-macosx_11_0_arm64.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.1'
-__version_tuple__ = version_tuple = (4, 12, 1)
+__version__ = version = '4.13.1'
+__version_tuple__ = version_tuple = (4, 13, 1)
 
-__commit_id__ = commit_id = 'g6f276d4df'
+__commit_id__ = commit_id = 'gdae14dc56'

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,
@@ -1258,85 +1259,86 @@ def reduce_to_one_layer(self: Grid) -> None:
     self._subgrids = None
 
 
-def translate_coordinates(
-    self: Grid,
-    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
-    flip: tuple[int, int, int] = (1, 1, 1),
+def reverse_row_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
 ) -> None:
-    """Translate grid coordinates."""
-    self._set_xtgformat1()
+    """Flip the row-axis for xtgformat=2 grid arrays.
 
-    tx, ty, tz = translate
-    fx, fy, fz = flip
+    This reverses the J-direction (rows) by flipping along axis 1 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
+        return
 
-    ier = _cxtgeo.grd3d_translate(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        fx,
-        fy,
-        fz,
-        tx,
-        ty,
-        tz,
-        self._coordsv,
-        self._zcornsv,
-    )
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in translate, code: {ier}")
+    self._set_xtgformat2()
 
-    logger.info("Translation of coords done")
+    # Flip coordsv along the row axis (axis 1) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=1).copy()
 
+    # For zcornsv, we need to flip along row axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After row flip: NW, NE, SW, SE (should become indices 0,1,2,3)
+    # So we need to rearrange: [2,3,0,1]
+    zcorns_flipped = np.flip(self._zcornsv, axis=1)  # Flip along row axis
+    self._zcornsv = zcorns_flipped[:, :, :, [2, 3, 0, 1]].copy()  # Reorder corners
 
-def reverse_row_axis(
-    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
-) -> None:
-    """Reverse rows (aka flip) for geometry and assosiated properties."""
-    if ijk_handedness == self.ijk_handedness:
-        return
+    # Also flip actnum along row axis
+    self._actnumsv = np.flip(self._actnumsv, axis=1).copy()
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # Update handedness
+    if self._ijk_handedness == "left":
+        self._ijk_handedness = "right"
+    else:
+        self._ijk_handedness = "left"
 
-    original_handedness = self._ijk_handedness
-    original_xtgformat = self._xtgformat
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=1).copy()
 
-    self._set_xtgformat1()
+    logger.info("Reversing of row axis done")
 
-    ier = _cxtgeo.grd3d_reverse_jrows(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        self._coordsv.ravel(),
-        self._zcornsv.ravel(),
-        self._actnumsv.ravel(),
-    )
 
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in jswapping, code: {ier}")
+def reverse_column_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
+) -> None:
+    """Flip the column-axis for xtgformat=2 grid arrays.
 
-    if self._props is None:
+    This reverses the I-direction (columns) by flipping along axis 0 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
         return
 
-    # do it for properties
-    if self._props.props:
-        for prp in self._props.props:
-            prp.values = prp.values[:, ::-1, :]
+    self._set_xtgformat2()
+
+    # Flip coordsv along the column axis (axis 0) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=0).copy()
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # For zcornsv, we need to flip along column axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After column flip: SE, SW, NE, NW (should become indices 0,1,2,3)
+    # So we need to rearrange: [1,0,3,2]
+    zcorns_flipped = np.flip(self._zcornsv, axis=0)  # Flip along column axis
+    self._zcornsv = zcorns_flipped[:, :, :, [1, 0, 3, 2]].copy()  # Reorder corners
 
-    if original_handedness == "left":
+    # Also flip actnum along column axis
+    self._actnumsv = np.flip(self._actnumsv, axis=0).copy()
+
+    # Update handedness
+    if self._ijk_handedness == "left":
         self._ijk_handedness = "right"
     else:
         self._ijk_handedness = "left"
 
-    if original_xtgformat == 2:
-        self._set_xtgformat2()
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=0).copy()
 
-    logger.info("Reversing of rows done")
+    logger.info("Reversing of column axis done")
 
 
 def get_adjacent_cells(
@@ -1399,7 +1401,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 +1421,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)