xtgeo 4.10.1__cp313-cp313-macosx_11_0_arm64.whl → 4.14.0__cp313-cp313-macosx_11_0_arm64.whl

xtgeo/__init__.py

@@ -116,6 +116,7 @@ from xtgeo.surface.regular_surface import (
     surface_from_cube,
     surface_from_file,
     surface_from_grid3d,
+    surface_from_rms,
     surface_from_roxar,
 )
 from xtgeo.surface.surfaces import Surfaces
@@ -236,6 +237,7 @@ __all__ = [
     "surface_from_cube",
     "surface_from_file",
     "surface_from_grid3d",
+    "surface_from_rms",
     "surface_from_roxar",
     "version",
     "well1",

xtgeo/common/version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '4.10.1'
-__version_tuple__ = version_tuple = (4, 10, 1)
+__version__ = version = '4.14.0'
+__version_tuple__ = version_tuple = (4, 14, 0)
+
+__commit_id__ = commit_id = 'g185b9b532'

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
@@ -63,15 +70,14 @@ class CubeAttrs:
     _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._create_reduced_cube()
-        self._refine_interpolate()
-        self._depth_mask()
+        self._determine_slice_indices()
         self._compute_statistical_attribute_surfaces()
 
     def result(self) -> dict[RegularSurface]:
@@ -83,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))
@@ -94,6 +102,7 @@ class CubeAttrs:
             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))
@@ -130,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.
@@ -140,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(
             [
@@ -173,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] = np.nan  # set dead traces to nan
+        logger.debug("Determine cube slice indices...")
 
         # Create a boolean mask based on the threshold
         mask = self._depth_array < self._outside_depth
@@ -198,116 +207,18 @@ 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)
 
@@ -315,26 +226,48 @@ class CubeAttrs:
         attr_map_resampled = self._template_surface.copy()
         attr_map_resampled.resample(attr_map)
 
-        attr_map_resampled.values = np.ma.masked_where(
-            self.upper_surface.values.mask, attr_map_resampled.values
-        )
+        # 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."""
-
-        # 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_grid.py

@@ -7,8 +7,12 @@ from typing import Any, List, Optional, Tuple, Union
 import numpy as np
 from scipy.constants import foot
 
+from xtgeo.common.log import null_logger
+
 from ._grdecl_format import match_keyword
 
+logger = null_logger(__name__)
+
 
 @unique
 class Units(Enum):
@@ -539,9 +543,9 @@ class EclGrid(ABC):
             has_axis_units = False
 
         if has_mapaxes and not has_axis_units:
-            warnings.warn(
+            logger.info(
                 "Axis units specification is missing in input, assuming that no "
-                "unit conversion is necessary"
+                "unit conversion is necessary."
             )
 
         if relative_to == GridRelative.MAP and not self.is_map_relative:

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/_grdecl_format.py

@@ -4,6 +4,8 @@ import warnings
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 
+import numpy as np
+
 from xtgeo.common import null_logger
 
 if TYPE_CHECKING:
@@ -15,6 +17,47 @@ if TYPE_CHECKING:
 logger = null_logger(__name__)
 
 
+def run_length_encoding(arr: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Perform run-length encoding on a 1D NumPy array.
+
+    Run-length encoding is a data compression technique that represents
+    consecutive  repeated values as a single value and its count.
+
+    Args:
+        arr (np.ndarray): A 1D NumPy array to be encoded.
+
+    Returns:
+        tuple[np.ndarray, np.ndarray]: A tuple containing two 1D NumPy arrays:
+            - counts (np.ndarray): An array of counts representing the number
+              of consecutive occurrences of each unique value.
+            - values (np.ndarray): An array of the unique values corresponding to
+              the counts.
+
+    Examples:
+        >>> import numpy as np
+        >>> arr = np.array([1, 1, 2, 2, 2, 3, 3, 1, 1, 1])
+        >>> counts, values = run_length_encoding(arr)
+        >>> print(counts)
+        [2 3 2 3]
+        >>> print(values)
+        [1 2 3 1]
+
+        >>> arr = np.array([5, 5, 5, 5, 5])
+        >>> counts, values = run_length_encoding(arr)
+        >>> print(counts)
+        [5]
+        >>> print(values)
+        [5]
+
+    """
+    change_indices = np.where(~np.isclose(arr[:-1], arr[1:]))[0] + 1
+    counts = np.diff(np.concatenate(([0], change_indices, [len(arr)])))
+    values = arr[np.concatenate(([0], change_indices))]
+
+    return counts, values
+
+
 def split_line(line: str) -> Generator[str, None, None]:
     """
     split a keyword line inside a grdecl file. This splits the values of a

xtgeo/grid3d/_grdecl_grid.py

@@ -41,7 +41,7 @@ from ._ecl_grid import (
     MapAxes,
     Units,
 )
-from ._grdecl_format import IGNORE_ALL, open_grdecl
+from ._grdecl_format import IGNORE_ALL, open_grdecl, run_length_encoding
 
 
 @dataclass
@@ -311,20 +311,22 @@ class GrdeclGrid(EclGrid):
                 results[kw.lower()] = factory(values)
         return cls(**results)
 
-    def to_file(self, filename, fileformat="grdecl"):
+    def to_file(self, filename, fileformat="grdecl", rle: bool = False):
         """
         write the grdeclgrid to a file.
         :param filename: path to file to write.
         :param fileformat: Either "grdecl" or "bgrdecl" to
             indicate binary or ascii format.
+        :param rle: Boolean flag indicating whether to use Run-Length Encoding (RLE)
+                    compression when writing the file (only for grdecl).
         """
         if fileformat == "grdecl":
-            return self._to_grdecl_file(filename)
+            return self._to_grdecl_file(filename, rle)
         if fileformat == "bgrdecl":
             return self._to_bgrdecl_file(filename)
         raise ValueError(b"Unknown grdecl file format {fileformat}")
 
-    def _to_grdecl_file(self, filename):
+    def _to_grdecl_file(self, filename, rle):
         with open(filename, "w") as filestream:
             keywords = [
                 ("SPECGRID", self.specgrid.to_grdecl()),
@@ -340,14 +342,24 @@ class GrdeclGrid(EclGrid):
                 if values is None:
                     continue
                 filestream.write(f"{kw}\n")
-                numcolumns = 0
-                for value in values:
-                    numcolumns += 1
-                    filestream.write(f" {value}")
-
-                    if numcolumns >= 6:  # 6 should ensure < 128 character width total
-                        filestream.write("\n")
-                        numcolumns = 0
+                if rle and (kw == "ACTNUM"):
+                    counts, unique_values = run_length_encoding(values)
+                    for i, (count, unique_value) in enumerate(
+                        zip(counts, unique_values)
+                    ):
+                        filestream.write(
+                            f" {count}*{unique_value}"
+                            if count > 1
+                            else f" {unique_value}"
+                        )
+                        if i % 6 == 5:
+                            filestream.write("\n")
+                else:
+                    for i, value in enumerate(values):
+                        filestream.write(f" {value}")
+
+                        if i % 6 == 5:  # 6 should ensure < 128 character width total
+                            filestream.write("\n")
 
                 filestream.write("\n /\n")