xtgeo 4.11.0__cp313-cp313-macosx_11_0_arm64.whl → 4.12.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.11.0'
-__version_tuple__ = version_tuple = (4, 11, 0)
+__version__ = version = '4.12.1'
+__version_tuple__ = version_tuple = (4, 12, 1)
 
-__commit_id__ = commit_id = 'gee9361dd9'
+__commit_id__ = commit_id = 'g6f276d4df'

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")
 

xtgeo/grid3d/_grid_etc1.py

@@ -309,23 +309,34 @@ def get_heights_above_ffl(
     grid: Grid,
     ffl: GridProperty,
     option: Literal[
-        "cell_center_above_ffl", "cell_corners_above_ffl"
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
     ] = "cell_center_above_ffl",
 ) -> tuple[GridProperty, GridProperty, GridProperty]:
     """Compute delta heights for cell top, bottom and midpoints above a given level."""
 
-    valid_options = ("cell_center_above_ffl", "cell_corners_above_ffl")
+    valid_options = (
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
+    )
     if option not in valid_options:
         raise ValueError(
             f"The option key <{option}> is invalid, must be one of {valid_options}"
         )
+    if option == "cell_center_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCenter
+    elif option == "cell_corners_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCorners
+    else:
+        option_flag = _internal.grid3d.HeightAboveFFLOption.TruncatedCellCorners
 
     grid._set_xtgformat2()
 
     grid_cpp = grid._get_grid_cpp()
     htop_arr, hbot_arr, hmid_arr = grid_cpp.get_height_above_ffl(
-        ffl.values.ravel(),
-        1 if option == "cell_center_above_ffl" else 2,
+        ffl.values.ravel(), option_flag
     )
 
     htop = GridProperty(

xtgeo/grid3d/_grid_export.py

@@ -49,10 +49,11 @@ def export_roff(
         )
 
 
-def export_grdecl(grid: Grid, gfile: FileLike, mode: int) -> None:
-    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0)."""
+def export_grdecl(grid: Grid, gfile: FileLike, mode: int, rle: bool = False) -> None:
+    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0).
+    Optionally for ASCII GRDECL, run-length encoding RLE can be applied"""
     fileformat = "grdecl" if mode == 1 else "bgrdecl"
-    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat)
+    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat, rle=rle)
 
 
 def export_egrid(grid: Grid, gfile: FileLike) -> None:

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_export.py

@@ -17,6 +17,7 @@ from xtgeo.common.exceptions import InvalidFileFormatError
 from xtgeo.common.log import null_logger
 from xtgeo.io._file import FileFormat, FileWrapper
 
+from ._grdecl_format import run_length_encoding
 from ._roff_parameter import RoffParameter
 
 if TYPE_CHECKING:
@@ -37,6 +38,7 @@ def to_file(
     append: bool = False,
     dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export the grid property to file."""
     logger.debug("Export property to file %s as %s", pfile, fformat)
@@ -62,6 +64,7 @@ def to_file(
             append=append,
             binary=binary,
             fmt=fmt,
+            rle=rle,
         )
     elif fformat == "xtgcpprop":
         _export_xtgcpprop(gridprop, xtg_file.name)
@@ -104,6 +107,7 @@ def _export_grdecl(
     append: bool = False,
     binary: bool = False,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export ascii or binary GRDECL"""
     vals: npt.NDArray = gridprop.values.ravel(order="F")
@@ -132,18 +136,36 @@ def _export_grdecl(
         else:
             # Always the case when not binary
             assert isinstance(fout, io.TextIOWrapper)
-            fout.write(name)
-            fout.write("\n")
-            for i, v in enumerate(vals):
-                fout.write(" ")
-                if fmt:
-                    fout.write(fmt % v)
-                elif gridprop.isdiscrete:
-                    fout.write(str(v))
-                else:
-                    fout.write(f"{v:3e}")
-                if i % 6 == 5:
-                    fout.write("\n")
+            fout.write(f"{name}\n")
+            if rle:
+                counts, unique_values = run_length_encoding(vals)
+                for i, (count, unique_value) in enumerate(zip(counts, unique_values)):
+                    fout.write(" ")
+                    if fmt:
+                        formatted_value = fmt % unique_value
+                    elif gridprop.isdiscrete:
+                        formatted_value = str(unique_value)
+                    else:
+                        formatted_value = f"{unique_value:3e}"
+                    if count > 1:
+                        # Try to preserve the alignment
+                        text_width = len(formatted_value)
+                        new_text = f"{count}*{formatted_value.lstrip()}"
+                        formatted_value = " " * (text_width - len(new_text)) + new_text
+                    fout.write(formatted_value)
+                    if i % 6 == 5:
+                        fout.write("\n")
+            else:
+                for i, v in enumerate(vals):
+                    fout.write(" ")
+                    if fmt:
+                        fout.write(fmt % v)
+                    elif gridprop.isdiscrete:
+                        fout.write(str(v))
+                    else:
+                        fout.write(f"{v:3e}")
+                    if i % 6 == 5:
+                        fout.write("\n")
             fout.write(" /\n")
 
 

xtgeo/grid3d/_gridprop_op1.py

@@ -25,6 +25,77 @@ _ValueList = List[List[_CoordOrValue]]
 XYValueLists = Tuple[_XYCoordList, _ValueList]
 
 
+def _validate_cast_range(values: np.ndarray, target_dtype: np.dtype) -> None:
+    """Validate that values fit in target dtype range."""
+    if np.issubdtype(target_dtype, np.integer):
+        info = np.iinfo(target_dtype)
+        min_val, max_val = info.min, info.max
+
+        # Check actual value ranges
+        actual_min = np.nanmin(values)
+        actual_max = np.nanmax(values)
+
+        if actual_min < min_val or actual_max > max_val:
+            raise ValueError(
+                f"Values [{actual_min}, {actual_max}] exceed {target_dtype} "
+                f"range [{min_val}, {max_val}]"
+            )
+    elif np.issubdtype(target_dtype, np.floating):
+        info = np.finfo(target_dtype)
+        # Check for overflow/underflow
+        if np.any(np.abs(values[np.isfinite(values)]) > info.max):
+            raise ValueError(f"Values too large for {target_dtype}")
+
+
+def discrete_to_continuous(self: GridProperty) -> None:
+    """Convert from discrete to continuous values."""
+    if not self.isdiscrete:
+        logger.debug("No need to convert, already continuous")
+        return
+
+    logger.debug("Converting to continuous ...")
+    val = self._values.copy()
+    val = val.astype(np.float64)
+    self._values = val
+    self._isdiscrete = False
+    self._codes = {}
+    self.roxar_dtype = np.float32
+
+
+def continuous_to_discrete(self) -> None:
+    """Convert from continuous to discrete values."""
+    if self.isdiscrete:
+        logger.debug("No need to convert, already discrete")
+        return
+
+    logger.debug("Converting to discrete ...")
+    val = self._values.copy()
+
+    # Validate finite values only
+    finite_vals = (
+        val[np.isfinite(val)]
+        if not isinstance(val, np.ma.MaskedArray)
+        else val.compressed()
+    )
+    if len(finite_vals) > 0:
+        _validate_cast_range(finite_vals, np.int32)
+
+    # Round and cast, suppressing the NaN warning
+    val = np.round(val)
+    with np.errstate(invalid="ignore"):
+        val = val.astype(np.int32)
+
+    self._values = val
+    self._isdiscrete = True
+
+    self._codes = {
+        v: str(v)
+        for v in np.ma.unique(val)
+        if np.isfinite(v) and not isinstance(v, np.ma.core.MaskedConstant)
+    }
+    self.roxar_dtype = np.uint16
+
+
 def get_xy_value_lists(
     self: GridProperty,
     grid: Optional[Grid | GridProperty] = None,
@@ -134,12 +205,6 @@ def operation_polygons(
 
     gl.update_values_from_carray(proxy, cvals, np.float64, delete=True)
 
-    proxyv = proxy.values.astype(np.int8)
-
-    proxytarget = 1
-    if not inside:
-        proxytarget = 0
-
     if opname == "add":
         tmp = self.values.copy() + value
     elif opname == "sub":
@@ -170,8 +235,9 @@ def operation_polygons(
     # convert tmp back to correct dtype
     tmp = tmp.astype(dtype)
 
-    self.values[proxyv == proxytarget] = tmp[proxyv == proxytarget]
-    del tmp
+    mask = proxy.values == 1 if inside else proxy.values == 0
+
+    self.values[mask] = tmp[mask]
 
 
 def refine(

xtgeo/grid3d/_gridprop_roxapi.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Literal
+from warnings import warn
 
 import numpy as np
 from numpy import ma
@@ -135,6 +136,51 @@ def export_prop_roxapi(
     rox.safe_close()
 
 
+def _validate_dtype_in_roxar(
+    pval: np.ndarray, original_dtype: Any, dtype: Any, allow_unsafe_casting: bool = True
+) -> None:
+    """Local routine that check the range in xtgeo's parameter vs Roxar dtype"""
+    message = ""
+
+    if dtype != original_dtype:
+        message += (
+            f"Existing RMS icon has data type {original_dtype} while "
+            f"GridProperty has RMS data type {dtype}. This may cause issues in data "
+            "content while saving to RMS."
+        )
+
+    try:
+        if np.issubdtype(dtype, np.integer):
+            # Integer type
+            min_val, max_val = np.iinfo(dtype).min, np.iinfo(dtype).max
+        elif np.issubdtype(dtype, np.floating):
+            # Float type
+            min_val, max_val = np.finfo(dtype).min, np.finfo(dtype).max
+        else:
+            # Unknown type
+            raise RuntimeError("Probable bug, values array not integer or float")
+
+        if pval.min() < min_val or pval.max() > max_val:
+            message += (
+                f"Values outside {dtype} range [{min_val}, {max_val}] found. "
+                f"Range in xtgeo values are [{pval.min()}, {pval.max()}]"
+            )
+
+    except (ValueError, OverflowError):
+        # Handle edge cases gracefully
+        message += f"Could not validate range for dtype {dtype}. "
+
+    if message and allow_unsafe_casting:
+        message += (
+            "\nUnsafe casting is allowed; this means that original values may "
+            "be truncated which may give unpredictable results and/or mess "
+            "up code names and values settings."
+        )
+
+    if message:
+        warn(message, UserWarning)
+
+
 def _store_in_roxar(
     self: GridProperty,
     pname: str,
@@ -147,50 +193,60 @@ def _store_in_roxar(
 
     logger.info("Store in RMS...")
 
-    val3d = self.values.copy()
-
-    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
-
-    ijk = indexer.get_indices(cellno)
+    roxtype: Any = roxar  # needed for mypy
+    roxar_property_type = (
+        roxtype.GridPropertyType.discrete
+        if self.isdiscrete
+        else roxtype.GridPropertyType.continuous
+    )
 
-    iind = ijk[:, 0]
-    jind = ijk[:, 1]
-    kind = ijk[:, 2]
+    val3d = self.values.copy()
 
     dtype = self._roxar_dtype
     logger.info("DTYPE is %s for %s", dtype, pname)
 
-    # casting will secure correct types
     if dtype not in VALID_ROXAR_DTYPES:
         raise TypeError(
             f"Roxar dtype is not valid: {dtype} must be in {VALID_ROXAR_DTYPES}"
         )
 
-    pvalues = roxgrid.get_grid(realisation=realisation).generate_values(data_type=dtype)
-
-    roxtype: Any = roxar  # needed for mypy
-    roxar_property_type = (
-        roxtype.GridPropertyType.discrete
-        if self.isdiscrete
-        else roxtype.GridPropertyType.continuous
-    )
-
-    pvalues[cellno] = val3d[iind, jind, kind]
-
     properties = roxgrid.properties
-
+    original_dtype = dtype
     if pname not in properties:
         rprop = properties.create(
             pname, property_type=roxar_property_type, data_type=dtype
         )
     else:
         rprop = properties[pname]
-        dtype = rprop.data_type
+        original_dtype = rprop.data_type
+
+    _validate_dtype_in_roxar(val3d, original_dtype, dtype, casting == "unsafe")
 
-    rprop.set_values(pvalues.astype(dtype, casting=casting), realisation=realisation)
+    dtype = original_dtype
+    val3d = val3d.astype(dtype, casting=casting)
 
-    if self.isdiscrete:
-        rprop.code_names = _rox_compatible_codes(self.codes)
+    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
+
+    ijk = indexer.get_indices(cellno)
+
+    iind = ijk[:, 0]
+    jind = ijk[:, 1]
+    kind = ijk[:, 2]
+
+    pvalues = roxgrid.get_grid(realisation=realisation).generate_values(data_type=dtype)
+
+    pvalues[cellno] = val3d[iind, jind, kind]
+    rprop.set_values(pvalues, realisation=realisation)
+
+    if self.isdiscrete and "float" not in str(original_dtype):
+        try:
+            rprop.code_names = _rox_compatible_codes(self.codes)
+        except ValueError as verr:
+            message = (
+                f"Trying to set codes in Roxar: {self.codes} for type "
+                f"{self._roxar_dtype}. {str(verr)} Consider editing the codes!"
+            )
+            raise ValueError(message)
 
 
 def _fix_codes(

xtgeo/grid3d/grid.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, Literal, NoReturn
+from typing import TYPE_CHECKING, Any, Literal
 
 import numpy as np
 import numpy.ma as ma
@@ -994,13 +994,16 @@ class Grid(_Grid3D):
     # Create/import/export
     # ==================================================================================
 
-    def to_file(self, gfile: FileLike, fformat: str = "roff") -> None:
+    def to_file(
+        self, gfile: FileLike, fformat: str = "roff", rle: bool = False
+    ) -> None:
         """Export grid geometry to file, various vendor formats.
 
         Args:
             gfile (str): Name of output file
             fformat (str): File format; roff/roff_binary/roff_ascii/
                 grdecl/bgrdecl/egrid.
+            rle (bool): Use run-length encoding (only for grdecl file)
 
         Raises:
             OSError: Directory does not exist
@@ -1018,7 +1021,7 @@ class Grid(_Grid3D):
         elif fformat in FileFormat.ROFF_ASCII.value:
             _grid_export.export_roff(self, _gfile.name, "ascii")
         elif fformat in FileFormat.GRDECL.value:
-            _grid_export.export_grdecl(self, _gfile.name, 1)
+            _grid_export.export_grdecl(self, _gfile.name, 1, rle)
         elif fformat in FileFormat.BGRDECL.value:
             _grid_export.export_grdecl(self, _gfile.name, 0)
         elif fformat in FileFormat.EGRID.value:
@@ -1577,9 +1580,30 @@ class Grid(_Grid3D):
 
         return self.get_subgrids()
 
-    def get_zoneprop_from_subgrids(self) -> NoReturn:
-        """Make a XTGeo GridProperty instance for a Zone property subgrid index."""
-        raise NotImplementedError("Not yet; todo")
+    def get_zoneprop_from_subgrids(self) -> xtgeo.GridProperty | None:
+        """
+        Create a discrete GridProperty encoding subgrid indices as zone values.
+
+        Returns:
+            A GridProperty where each layer belonging to a subgrid is assigned a unique
+            integer zone index (starting from 1). The property codes map these indices
+            to subgrid names. Returns None if no subgrids are defined.
+        """
+        if not self.subgrids:
+            return None
+
+        zoneprop = xtgeo.GridProperty(
+            ncol=self.ncol,
+            nrow=self.nrow,
+            nlay=self.nlay,
+            name="Zone",
+            discrete=True,
+            values=0,
+        )
+        for i, (name, layers) in enumerate(self.subgrids.items()):
+            zoneprop.codes[i + 1] = name
+            zoneprop.values[:, :, min(layers) - 1 : max(layers)] = i + 1
+        return zoneprop
 
     def get_boundary_polygons(
         self: Grid,
@@ -1966,12 +1990,14 @@ class Grid(_Grid3D):
             ffl: Free fluid level e.g. FWL (or level whatever is required; a level from
                 which cells above will be shown as delta heights (positive), while
                 cells below will have 0.0 values.
-            option: How to compute values, as either "cell_center_above_ffl" or
-                "cell_corners_above_ffl". The first one looks at cell Z centerlines, and
-                compute the top, the bottom and the midpoint. The second will look at
-                cell corners, using the uppermost corner for top, and the lowermost
-                corner for bottom. In both cases, values are modified if cell is
-                intersected with the provided ffl.
+            option: How to compute values, as either "cell_center_above_ffl",
+                "cell_corners_above_ffl" or "truncated_cell_corners_above_ffl".
+                The first one looks at cell Z centerlines, and compute the top,
+                the bottom and the midpoint. The second will look at cell corners,
+                using the uppermost corner for top, and the lowermost corner for bottom.
+                The third will truncate all cell corners above ffl and compute cell Z
+                centerlines. In all cases, values are modified if cell is intersected
+                with the provided ffl.
 
         Returns:
             (htop, hbot, hmid) delta heights, as xtgeo GridProperty objects

xtgeo/grid3d/grid_property.py

@@ -773,6 +773,7 @@ class GridProperty(_Grid3D):
         append: bool = False,
         dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
         fmt: str | None = None,
+        rle: bool = False,
     ) -> None:
         """
         Export the grid property to file.
@@ -791,6 +792,7 @@ class GridProperty(_Grid3D):
                 Eclipse formats.
             fmt: Format for ascii grdecl format. Default is None. If specified,
                 the user is responsible for a valid format specifier, e.g. "%8.4f".
+            rle: Use run length encoding, only for grdecl format.
 
         Example::
 
@@ -815,6 +817,7 @@ class GridProperty(_Grid3D):
             append=append,
             dtype=dtype,
             fmt=fmt,
+            rle=rle,
         )
 
     @classmethod
@@ -1222,36 +1225,11 @@ class GridProperty(_Grid3D):
 
     def discrete_to_continuous(self) -> None:
         """Convert from discrete to continuous values."""
-        if not self.isdiscrete:
-            logger.debug("No need to convert, already continuous")
-            return
-
-        logger.debug("Converting to continuous ...")
-        val = self._values.copy()
-        val = val.astype("float64")
-        self._values = val
-        self._isdiscrete = False
-        self._codes = {}
-        self.roxar_dtype = np.float32
+        _gridprop_op1.discrete_to_continuous(self)
 
     def continuous_to_discrete(self) -> None:
         """Convert from continuous to discrete values."""
-        if self.isdiscrete:
-            logger.debug("No need to convert, already discrete")
-            return
-
-        logger.debug("Converting to discrete ...")
-        val = self._values.copy()
-        val = val.astype(np.int32)
-        self._values = val
-        self._isdiscrete = True
-
-        # make the code list
-        uniq = np.unique(val).tolist()
-        codes = dict(zip(uniq, uniq))
-        codes = {k: str(v) for k, v in codes.items()}  # val as strings
-        self._codes = codes
-        self.roxar_dtype = np.uint16
+        _gridprop_op1.continuous_to_discrete(self)
 
     # ==================================================================================
     # Operations restricted to inside/outside polygons

xtgeo/lib/cmake/fmt/fmt-targets.cmake

@@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "3.0.0")
    message(FATAL_ERROR "CMake >= 3.0.0 required")
 endif()
 cmake_policy(PUSH)
-cmake_policy(VERSION 3.0.0...3.29)
+cmake_policy(VERSION 3.0.0...3.31)
 #----------------------------------------------------------------
 # Generated CMake target import file.
 #----------------------------------------------------------------

xtgeo/lib/pkgconfig/fmt.pc

@@ -1,5 +1,5 @@
-prefix=/var/folders/x7/ch5v91h56_zbvbd1y2f600dm0000gn/T/tmpz8dlfpcv/wheel/platlib/xtgeo
-exec_prefix=/var/folders/x7/ch5v91h56_zbvbd1y2f600dm0000gn/T/tmpz8dlfpcv/wheel/platlib/xtgeo
+prefix=/var/folders/sw/lqy3v8g55m76fhwckg439jjm0000gn/T/tmpyg9b8fob/wheel/platlib/xtgeo
+exec_prefix=/var/folders/sw/lqy3v8g55m76fhwckg439jjm0000gn/T/tmpyg9b8fob/wheel/platlib/xtgeo
 libdir=${exec_prefix}/lib
 includedir=${prefix}/include
 

{xtgeo-4.11.0.dist-info → xtgeo-4.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xtgeo
-Version: 4.11.0
+Version: 4.12.1
 Summary: XTGeo is a Python library for 3D grids, surfaces, wells, etc
 Keywords: grids,surfaces,wells,cubes
 Author-Email: Equinor <fg_fmu-atlas@equinor.com>
@@ -14,7 +14,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -27,7 +26,7 @@ Project-URL: Homepage, https://github.com/equinor/xtgeo
 Project-URL: Repository, https://github.com/equinor/xtgeo
 Project-URL: Issues, https://github.com/equinor/xtgeo/issues
 Project-URL: Documentation, https://xtgeo.readthedocs.io
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: deprecation
 Requires-Dist: h5py>=3
 Requires-Dist: hdf5plugin>=2.3
@@ -92,7 +91,7 @@ Detailed documentation for [XTGeo at Read _the_ Docs](https://xtgeo.readthedocs.
 
 ## Feature summary
 
--   Python 3.9+ support
+-   Python 3.10+ support
 -   Focus on high speed, using numpy and pandas with C backend
 -   Regular surfaces, i.e. 2D maps with regular sampling and rotation
 -   3D grids (corner-point), supporting several formats such as

{xtgeo-4.11.0.dist-info → xtgeo-4.12.1.dist-info}/RECORD

@@ -1,8 +1,12 @@
 cxtgeo.py,sha256=MjY_SfwNrahCXED08vVn7OsQPQPU7rsKwxSp2GY5WKI,33396
 cxtgeoPYTHON_wrap.c,sha256=jdx6wYGtLu7KKXcEHC9XqRTEMkYc4x4D07FPmYKSjPE,635145
-xtgeo/_cxtgeo.cpython-313-darwin.so,sha256=un1ivrKTpbu2dSccdaH-RB9mac4_3nPTb_TQvHxCr1I,414880
+xtgeo-4.12.1.dist-info/RECORD,,
+xtgeo-4.12.1.dist-info/WHEEL,sha256=RKB2kgklE3rgz0xlIuKYm-O5gcSzEoMvCOiEOfbYfDs,141
+xtgeo-4.12.1.dist-info/METADATA,sha256=_bQC78VJmRcAEiNh0saCXL7wAfj0v0NO0NorLX8PaRk,5741
+xtgeo-4.12.1.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+xtgeo/_cxtgeo.cpython-313-darwin.so,sha256=0SZPNNTIaYpi9OqxA8OqSkgjet0FbZ8OXB-_BtTaR2k,414912
 xtgeo/__init__.py,sha256=-p6vKOv7EfAt1S-7CmWHfN8iHjFHQ--5UwhIysS_gRQ,5588
-xtgeo/_internal.cpython-313-darwin.so,sha256=ipjSzdstXBTJB2dbjzj_ZncBKyixA__kG2TrjjvGbRA,715056
+xtgeo/_internal.cpython-313-darwin.so,sha256=4GuQO8vZywyhU1Yk1GdUsPMPZnL8QNBm_XAAImUo7sU,731840
 xtgeo/well/_wells_utils.py,sha256=hjJEBdtILtK87sbCYWHJ7aEgqgKkak6ihfOcxSixNPo,4945
 xtgeo/well/_blockedwell_roxapi.py,sha256=G0IEChtCF7SPV_nXDIYsJ5L601HjA9QdWU7cNoyJyus,7489
 xtgeo/well/_well_io.py,sha256=CHvLfuIVNoX_4PQd7sCWg5xvyCd1L73J5dkmV2uaJqU,9821
@@ -32,42 +36,42 @@ xtgeo/include/fmt/std.h,sha256=ogzbgTUxCUFupDozCWAG0yMhWeiV6QtkEbaR0p9jR8A,22277
 xtgeo/include/fmt/base.h,sha256=E8jZU_stmNyVUondFmmZvSLbq_66f0hrNpPCxtnWJ9s,103990
 xtgeo/grid3d/_grid_import.py,sha256=T--Nk4CVKifCskc2i8y6cpFXV2LZdTmJC3iSxKXXiZE,2593
 xtgeo/grid3d/_roff_parameter.py,sha256=UNS2cngVP3GIAr5nVCoGQYJq062KtfvCAkFb0FEJY68,11073
-xtgeo/grid3d/grid.py,sha256=8ImGx_fgKcbcsnV3GuxWX_9sPxK_iWe3cPWbAmI6bjA,105740
+xtgeo/grid3d/grid.py,sha256=hzKS9W51pgWl6WKHgykqpVyyo11pLGmHF4nTgpe0pm8,106706
 xtgeo/grid3d/_grid_boundary.py,sha256=oxWmQdy9cG1PzAtOH-IcCqAQYfmIwTD87tc-c4VgTA8,2308
 xtgeo/grid3d/_grid_import_ecl.py,sha256=gIcX4uMnwg0UnYMXyUdJsFSNKV-yhLFtc88AL1fmx6Y,3453
-xtgeo/grid3d/_gridprop_roxapi.py,sha256=4asCcVUXF42TKyD3oXTavBdPkAcAjZsra9QI12I3has,6857
-xtgeo/grid3d/_gridprop_op1.py,sha256=7xiGJe9rK4pKNux1rOi-UWcuPYKZAd6TqlBTmkryjjM,6813
+xtgeo/grid3d/_gridprop_roxapi.py,sha256=llGUYpBeLhj3A7bf3EcMe2kz-OiW_O-Y6JCjsqVM-e0,8967
+xtgeo/grid3d/_gridprop_op1.py,sha256=o0JemRzyECX0qzUpj9OXGB9nb1IOZ8-5Gs-1i_a302g,8956
 xtgeo/grid3d/_grid_import_roff.py,sha256=UViMnU44b75x4EfgnEmUYLFTK0R33lS9wAw0aBgzVzw,4039
 xtgeo/grid3d/_grid_hybrid.py,sha256=e-wj_RKknOSqPMU3wMBG_0maYJLEqJnv1_zp5eG55MY,1600
 xtgeo/grid3d/_grid3d_fence.py,sha256=XdIY-TlSgoTuRtRyRNqLvXLoR9F1QTEkFJO-rgKlqwE,9217
 xtgeo/grid3d/_grid3d.py,sha256=eM6842v2Q1Sb75zM3KynCITeV57OlXcusGEa_NWLPSU,740
 xtgeo/grid3d/_ecl_output_file.py,sha256=WPb7VGPyt89MpKtxL2jLoSKwn04jIfNsB11L-9wMhSY,2014
-xtgeo/grid3d/_grdecl_grid.py,sha256=R5zm3ninIts17pGWPbVI-1a747s9Igwj7pZXIylS4I4,12893
-xtgeo/grid3d/_grid_refine.py,sha256=qHdiHF2DJRhP6QGzPryr2nsghZtWAgscBi8kLgIDCTM,8541
+xtgeo/grid3d/_grdecl_grid.py,sha256=Er13V2E-4LtvpeLwFA-EhGKJxqWU-LUzR-OMZTKPoZo,13602
+xtgeo/grid3d/_grid_refine.py,sha256=VgcwTyUPafgtLRb5Cam0GbW7DJiL94xBgj1yM6fKKQM,8558
 xtgeo/grid3d/_roff_grid.py,sha256=Or-QR92AB_oE-6lbMVhQjXC_E1HAcxZjFlbep3cFo6w,17272
 xtgeo/grid3d/__init__.py,sha256=k6T-xKWIBey_WMjWDnYZfvCsLQGokCL9RjqBZNvbUq0,332
 xtgeo/grid3d/types.py,sha256=s4iR1hmpZ_mF7xLXqujZaT2Sa6RK0uA48ZywBmkjoD0,275
-xtgeo/grid3d/_grid_export.py,sha256=bzjHHcwVggip3efzwSHI6Sl0Sw-EIqT_f3GJAcFkJsk,7170
+xtgeo/grid3d/_grid_export.py,sha256=2Idg_5OGwS3Swu992RqYovDHBxfakjphN6ozKnDU1V0,7270
 xtgeo/grid3d/_ecl_inte_head.py,sha256=F22CT5VOpIYED2tMgmR5_FWtwq843S5vV3IbYvTehHM,4625
 xtgeo/grid3d/_gridprop_import_eclrun.py,sha256=k1SjOp4PmZ3nIcDM6N-2FDvDx3jMPf7rea3IGOrgo88,5096
 xtgeo/grid3d/_grid3d_utils.py,sha256=zIQZpWqAf33nVpC2aDqquPhd7Tqr-rRZvAaXPF-kxG0,7249
 xtgeo/grid3d/_ecl_grid.py,sha256=f12-cvxZblUZSAGIxKxJ438akK5gBFYebgSbVxZP6Jc,25905
 xtgeo/grid3d/_grid_roxapi.py,sha256=DJnG2CL56ygt2OEdVyH3oiMoyud-bra08tuLpFedCWQ,8907
 xtgeo/grid3d/_ecl_logi_head.py,sha256=CzBi7MSyPFeFGIKeBcex8qgm6VICUY6YjiKs0X9_UR4,2664
-xtgeo/grid3d/_grdecl_format.py,sha256=qUxq4c4e4-HGccFshLoOoGkgwwpaZeMbnWi4PhxPA78,8775
+xtgeo/grid3d/_grdecl_format.py,sha256=Nrp-dUh8p6G0WgDiWRfY_otxPwS_wUaUpReXVoj-U_s,10138
 xtgeo/grid3d/_grid_wellzone.py,sha256=cBLmO4YL62vHEVvltxFHyQScZIY2RQQcrIqq9Cx6euE,5786
 xtgeo/grid3d/_find_gridprop_in_eclrun.py,sha256=zUv1Fk5ouSICYd9SR7NpHbN78rFBcN7FBlURmeyaedk,21434
 xtgeo/grid3d/_gridprop_lowlevel.py,sha256=8aUDxj1mPu8yH0F9FVaxxumew1OdBOkwEQI5tjIZEQI,5086
-xtgeo/grid3d/_grid_etc1.py,sha256=54q91KLpkvtYweWHer7Fq18O0haA2nP-K-nikGPl-dI,43173
+xtgeo/grid3d/_grid_etc1.py,sha256=Yt5AjeXJ6xPbUlIbzer6N37_Cv53NVkxO2nnhY2uVWU,43571
 xtgeo/grid3d/_gridprops_import_eclrun.py,sha256=kWzubpyeorvfUSEjIF-UdoGnzQYYsUePW2jUtgoTuf0,11438
 xtgeo/grid3d/_gridprop_import_roff.py,sha256=tXp_mMqwfblSEb5KUbMOcL-TgGVn--vEqzPeXAK1IuI,1523
-xtgeo/grid3d/_gridprop_export.py,sha256=J_EL1bfs2ZB0B-foQLRhYjCQ1lB40yVHUD_utrd3TlU,5456
+xtgeo/grid3d/_gridprop_export.py,sha256=i4aukBXCeoYYIVJytG8ObjA1KyDGQqsQr2XukSSbZYg,6533
 xtgeo/grid3d/_gridprop_import_grdecl.py,sha256=t2Heqw5f9azf_LJlIae-vMe9s0-HJr88TIKZCeTfqpc,4133
 xtgeo/grid3d/_egrid.py,sha256=zOYcmK_3-BrCwHLZiZis7nuzdm_n0jPq_P2_J0X4_wY,33835
 xtgeo/grid3d/_grid_import_xtgcpgeom.py,sha256=VtLKqxwNRZYlrPFRPHq-GUO0er-qLkmRlHVrhiTMosA,10202
 xtgeo/grid3d/grid_properties.py,sha256=Ur2gPRV69JEfLidUxRulr5lO2pKMs6CVsFtxp5ZLMIo,24294
 xtgeo/grid3d/_gridprops_import_roff.py,sha256=u6UobGgMaIBrCUOvGotAv_PJAoAJQYaFGH_kGo1RvRY,2467
-xtgeo/grid3d/grid_property.py,sha256=MDcyEpCXAW6eLLOO3E129rVNv3zURkwPAWhnT_33O7A,45352
+xtgeo/grid3d/grid_property.py,sha256=aeBgWQ9cGq3ZPSuWm9crlFulWP25Leu21V4Ax51KvqQ,44667
 xtgeo/grid3d/_gridprop_import_xtgcpprop.py,sha256=-9576pMYO78IZl4VgaI_dk-ArCh0LRHt6cQL8MyEgos,4859
 xtgeo/grid3d/_gridprop_value_init.py,sha256=tN3LVziZsyIxbghkpGt6tCsHWFvGEm1e8ZpYpBgBdB8,4314
 xtgeo/cube/_cube_roxapi.py,sha256=mj9Nnug13t_Fsu0w4KKaJNEmrB_kYb0m133T6W-7wt0,4921
@@ -109,7 +113,7 @@ xtgeo/surface/_regsurf_cube.py,sha256=xZXIE418guB3rG8iscI9xQ0deAtJ_auu1XDe3ml9GB
 xtgeo/surface/_regsurf_utils.py,sha256=P91jVmstYGe-bn6ut-9xfd8DiOw7QUCt2DLwbnlJwB4,2307
 xtgeo/surface/_regsurf_import.py,sha256=IXD1T4hLRk705RbixSfcOxyrBUilRRbUHYC_S_xZqZA,10396
 xtgeo/common/_xyz_enum.py,sha256=IiKRWhvIKKRhUH2QwpDttW4XqJ4f4StPrVt1vfVBTxM,1045
-xtgeo/common/version.py,sha256=O12saSYjwbRCsG-uGD4_hG7qeZhWVDdXRNxpZkiz9TU,714
+xtgeo/common/version.py,sha256=2O2wY2SWIqA5uRiQW5SoPKR83a3fWIokUR1A5gARznI,714
 xtgeo/common/log.py,sha256=3C_WdYpCMEr5ebIGoGmalXNP0O2IGvLuJdzeuR8Cd-o,2742
 xtgeo/common/xtgeo_dialog.py,sha256=AcT8DrIBViSZJltwZuEfrcRbmicQEFfbwlf_gV2-6k8,17129
 xtgeo/common/constants.py,sha256=vp6k7lkWKKxyvojQZ1yYhhwXRXGZlMCPK8WY9nG2yns,749
@@ -119,19 +123,15 @@ xtgeo/common/_angles.py,sha256=VuNLV9pTooF_V3thFTg9SmTMBnKkv6ZxyvOXw22vLE0,822
 xtgeo/common/calc.py,sha256=xrJIVqFlrPIjhORbMThQylbjD4xdMM_vtEqBu5vc7C8,10134
 xtgeo/common/exceptions.py,sha256=4BRCtzk74eyc4LeeapAWFLkNh-TT0ev5pDxKJlPaI7s,1175
 xtgeo/common/sys.py,sha256=NGxnVoPoAGx_lekTF9QPBEf-VF8ORp4buoBeh6jkZko,4978
-xtgeo/lib/libfmt.a,sha256=n3om3j8Qpx7HiZMfFVn9mzDEhOzoXFT2BYvAupGGx_w,165328
-xtgeo/lib/pkgconfig/fmt.pc,sha256=cjFEWeBoIasLcEgyOnUuQz3Fmis5RWn4S6l68kzkhlw,353
+xtgeo/lib/libfmt.a,sha256=-h2otA_71Xwh0tJk6GWOWLbZclTUqpS32X-Dp8K1Wbk,163432
+xtgeo/lib/pkgconfig/fmt.pc,sha256=pdiIKyM5zXKRv3erJxPKDTOhwX9_9PUg-44JGvsbm5o,353
 xtgeo/lib/cmake/fmt/fmt-targets-release.cmake,sha256=0hurnnAYtVc8r8yvaxkXAS5Op01RPnwKE6SFNOL1nYA,807
 xtgeo/lib/cmake/fmt/fmt-config.cmake,sha256=Cd-Xn_HSZ-Lk5ZBDX8q49OQKSvnS0_k4r0-tb6G8LW4,999
 xtgeo/lib/cmake/fmt/fmt-config-version.cmake,sha256=p1j16l20z3aEnEsIu-cbcrqFT32K2IJNZl10B8Ww2pk,1862
-xtgeo/lib/cmake/fmt/fmt-targets.cmake,sha256=311cnawW6a6LfThZkmD63ECINF5kzP6ZDIPUNuQocoQ,4464
+xtgeo/lib/cmake/fmt/fmt-targets.cmake,sha256=ldmu9wnYq11UbsJ79TSK4ejJA-Zr20Ih9DyGS7EbPHM,4464
 xtgeo/roxutils/roxutils.py,sha256=BGvnWhYKvX2h7eU0ZXNUuDnHi8IM_2lLIzpq9lWZI6M,6904
 xtgeo/roxutils/__init__.py,sha256=UJKTgNSIGdtRxaUAwot4D5sGCTdfITw6BRaOnGkk41k,92
 xtgeo/roxutils/_roxutils_etc.py,sha256=K1fJKFBinfj32GGYnauU5t1sIgJ0l7N2gkXvaxMpNS8,3730
 xtgeo/roxutils/_roxar_loader.py,sha256=R2yBt7su6_u87UP00lLaiDxW0QuSnFLkEJQgcTWhjZI,1904
 xtgeo/metadata/metadata.py,sha256=mGkjNYcU4Y11EoLKTzSNW6JYpJVvIYNCbQ8obKMv21g,12436
 xtgeo/metadata/__init__.py,sha256=WXmKZjBGV3kr-lmrPxr3Ph7CpI5KIn3WKlE23crBteA,320
-xtgeo-4.11.0.dist-info/RECORD,,
-xtgeo-4.11.0.dist-info/WHEEL,sha256=oJkm-7pl427_FLH0y-nfECHsLYMFPsnLdg-NpvQlPbg,141
-xtgeo-4.11.0.dist-info/METADATA,sha256=_ORJH3UT7GiS4VR4R8EJ5sw4uahZ_BjT6yugeM_76sU,5789
-xtgeo-4.11.0.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652

{xtgeo-4.11.0.dist-info → xtgeo-4.12.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.5
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_11_0_arm64
 Generator: delocate 0.13.0