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

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,57 @@ 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:
+        # for mypy
+        min_val: int | float
+        max_val: int | float
+
+        if np.issubdtype(dtype, np.integer):
+            # Integer type
+            min_val = int(np.iinfo(dtype).min)
+            max_val = int(np.iinfo(dtype).max)
+        elif np.issubdtype(dtype, np.floating):
+            # Float type
+            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")
+
+        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 +199,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
@@ -28,6 +28,7 @@ from . import (
     _grid_import_ecl,
     _grid_refine,
     _grid_roxapi,
+    _grid_translate_coords,
     _grid_wellzone,
     _gridprop_lowlevel,
 )
@@ -994,13 +995,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 +1022,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 +1581,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,
@@ -1794,7 +1819,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)
@@ -1830,7 +1857,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)
@@ -1860,7 +1888,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)
@@ -1955,6 +1984,59 @@ class Grid(_Grid3D):
             self, name=name, precision=precision, asmasked=asmasked
         )
 
+    def get_phase_volumes(
+        self,
+        water_contact: float | GridProperty,
+        gas_contact: float | GridProperty,
+        boundary: Polygons | None = None,
+        asmasked: bool = True,
+        precision: Literal[1, 2, 4] = 2,
+    ) -> tuple[GridProperty, GridProperty, GridProperty]:
+        """Return the geometric phase cell volume for all cells as three
+        GridProperty objects, namely gas_bulkvol, oil_bulkvol and water_bulkvol.
+
+        The volume calculation is constrained to the area within the provided
+        boundary polygon. In case of multiple polygons, only the first polygon
+        will be used.
+
+        A bulk volume of a cornerpoint cell is a non-trivial and non-unique
+        quantity. The volume is approximated by dividing the cell (hexahedron)
+        into six tetrahedrons; there are multiple ways to perform this division.
+
+        By default (precision=2) an average of two different tetrahedral
+        decompositions is used.
+
+        Args:
+            water_contact: Water-oil contact, in most cases refers to free water level.
+            gas_contact: Gas-oil contact, in most cases refers to free gas level.
+            boundary: Boundary area. If multiple polygons are present, only the
+                first polygon is used.
+            asmasked: If True, make a numpy.ma array where inactive cells are
+                masked. Otherwise a numpy array with bulk volumes for all cells
+                is returned.
+            precision (int): An even number indicating precision level, where a
+                higher number increases precision and computing time. Currently
+                1, 2 and 4 are supported.
+        Returns:
+            Three XTGeo GridProperty objects: gas, oil and water volumes.
+
+        Example::
+
+            >>> grid = xtgeo.grid_from_file("myGrid.roff")
+            >>> gas, oil, water = grid.get_phase_volumes(
+            ...     water_contact=1700.0, gas_contact=1650.0
+            ... )
+            >>> print(f"Total gas volume: {gas.values.sum()}")
+        """
+        return _grid_etc1.get_phase_bulk_volumes(
+            self,
+            water_contact=water_contact,
+            gas_contact=gas_contact,
+            boundary=boundary,
+            precision=precision,
+            asmasked=asmasked,
+        )
+
     def get_heights_above_ffl(
         self,
         ffl: GridProperty,
@@ -1966,12 +2048,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
@@ -2295,7 +2379,7 @@ class Grid(_Grid3D):
         * maxangle_topbase_proj (degrees) max angle projected (bird view)
         * minangle_sides (degress) minimum angle, all side surfaces
         * maxangle_sides (degress) maximum angle, all side surfaces
-        * collapsed (int) Integer, 1 of one or more corners are collpased in Z
+        * collapsed (int) Integer, 1 of one or more corners are collapsed in Z
         * faulted (int) Integer, 1 if cell is faulted (one or more neighbours offset)
         * negative_thickness (int) Integer, 1 if cell has negative thickness
         * concave_proj (int) 1 if cell is concave seen from projected bird view
@@ -2332,7 +2416,7 @@ class Grid(_Grid3D):
         inside: bool = True,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid inside a polygon.
+        """Inactivate grid inside a polygon.
 
         The Polygons instance may consist of several polygons. If a polygon
         is open, then the flag force_close will close any that are not open
@@ -2359,14 +2443,30 @@ class Grid(_Grid3D):
         layer_range: tuple[int, int] | None = None,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid outside a polygon."""
+        """Inactivate grid outside a polygon."""
         self.inactivate_inside(
             poly, layer_range=layer_range, inside=False, force_close=force_close
         )
 
-    def collapse_inactive_cells(self) -> None:
-        """Collapse inactive layers where, for I J with other active cells."""
-        _grid_etc1.collapse_inactive_cells(self)
+    def collapse_inactive_cells(self, internal: bool = True) -> None:
+        """Collapse inactive layers per I J column (~vertically).
+
+        Seen by I,J column, the inactive cells are collapsed to the first active cell in
+        the column. First transversed from top, then from bottom. If no active cells in
+        the column, the (invisible) Z coordinates are averaged to one common location.
+
+        If `internal` is True (default), then also internal inactive cells (i.e.
+        inactive "hole" surrounded by active cells) are collapsed. In this case the Z
+        coordinates of the adjacent active cells are moved to fill the gap.
+
+        The current grid instance will be updated.
+
+        Args:
+            internal: If True (default), then the internal collapse is also done.
+
+        .. versionchanged:: 4.11 Added ``internal option``, algorithm is improved
+        """
+        _grid_etc1.collapse_inactive_cells(self, internal=internal)
 
     def crop(
         self,
@@ -2434,21 +2534,48 @@ class Grid(_Grid3D):
     def translate_coordinates(
         self,
         translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        target_coordinates: tuple[float, float, float] | None = None,
         flip: tuple[int, int, int] = (1, 1, 1),
-    ) -> None:
-        """Translate (move) and/or flip grid coordinates in 3D.
+        add_rotation: float = 0.0,
+        rotation_point: tuple[float, float] | None = None,
+    ) -> Grid | None:
+        """Translate (move), flip and rotate the 3D grid geometry.
 
-        By 'flip' here, it means that the full coordinate array are multiplied
-        with -1.
+        By 'flip' here, it means that the full coordinate arrays are inverted.
 
         Args:
-            translate (tuple): Translation distance in X, Y, Z coordinates
-            flip (tuple): Flip array. The flip values must be 1 or -1.
+            translate: Translation distance in X, Y, Z coordinates; these
+                values will be added to the current coordinates.
+            target_coordinates: Position for the centerpoint of the active grid cells.
+                Note that key ``translate`` cannot be used with this key; i.e. use
+                either ``translate`` or ``target_coordinates``
+            flip: Flip array. The flip values must be 1 or -1, meaning 1 for
+                keeping the current, and -1 for activating an axis flip.
+            add_rotation: The grid geometry will get an additional rotation by this
+                value, in degrees and counter clock wise.
+            rotation_point: Which (x, y) coordiate to be set as origin when adding
+                rotation. Default is the corner of the first cell number.
+
+        Note:
+            Grid properties attached to the grid will also be transformed
+
+        Example::
+            import xtgeo
+            grd = xtgeo.grid_from_roxar(project, "simpleb8")
+            poro = xtgeo.gridproperty_from_roxar(project, "simpleb8", "PORO")
+            grd.props = [poro]
+
+            grd.translate_coordinates(translate=(10,10, 20), flip=(1,1,-1),
+                add_rotation=30)
+
+            grd.to_roxar(project, "simpleb8_translated")
+            poro1 = grd.get_prop_by_name("PORO")
+            poro1.to_roxar(project, "simpleb8_translated", "PORO")
 
-        Raises:
-            RuntimeError: If translation goes wrong for unknown reasons
         """
-        _grid_etc1.translate_coordinates(self, translate=translate, flip=flip)
+        _grid_translate_coords.translate_coordinates(
+            self, translate, flip, add_rotation, rotation_point, target_coordinates
+        )
 
     def reverse_row_axis(
         self, ijk_handedness: Literal["left", "right"] | None = None
@@ -2456,7 +2583,7 @@ class Grid(_Grid3D):
         """Reverse the row axis (J indices).
 
         This means that IJK system will switched between a left vs right handed system.
-        It is here (by using ijk_handedness key), possible to set a wanted stated.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
 
         Note that properties that are assosiated with the grid (through the
         :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
@@ -2482,6 +2609,38 @@ class Grid(_Grid3D):
         """
         _grid_etc1.reverse_row_axis(self, ijk_handedness=ijk_handedness)
 
+    def reverse_column_axis(
+        self, ijk_handedness: Literal["left", "right"] | None = None
+    ) -> None:
+        """Reverse the column axis (I indices).
+
+        This means that IJK system will switched between a left vs right handed system.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
+
+        Note that properties that are assosiated with the grid (through the
+        :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
+        reversed (which is desirable).
+
+        Args:
+            ijk_handedness (str): If set to "right" or "left", do only reverse columns
+                if handedness is not already achieved.
+
+        Example::
+
+            grd = xtgeo.grid_from_file("somefile.roff")
+            prop1 = xtgeo.gridproperty_from_file("somepropfile1.roff")
+            prop2 = xtgeo.gridproperty_from_file("somepropfile2.roff")
+
+            grd.props = [prop1, prop2]
+
+            # secure that the grid geometry is IJK right-handed
+            grd.reverse_column_axis(ijk_handedness="right")
+
+        .. versionadded:: 4.14
+
+        """
+        _grid_etc1.reverse_column_axis(self, ijk_handedness=ijk_handedness)
+
     def make_zconsistent(self, zsep: float | int = 1e-5) -> None:
         """Make the 3D grid consistent in Z, by a minimal gap (zsep).
 
@@ -2514,11 +2673,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)::
@@ -2535,6 +2696,7 @@ class Grid(_Grid3D):
         .. _usage in the Troll field: https://doi.org/10.2118/148023-MS
 
         """
+
         _grid_hybrid.make_hybridgrid(
             self,
             nhdiv=nhdiv,

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