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

xtgeo/surface/_regsurf_oper.py

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

xtgeo/surface/regular_surface.py

@@ -17,7 +17,7 @@ Note that an instance of a regular surface can be made directly with::
 
 or::
 
- mysurf = xtgeo.surface_from_roxar('some_rms_project', 'TopX', 'DepthSurface')
+ mysurf = xtgeo.surface_from_rms('some_rms_project', 'TopX', 'DepthSurface')
 
 """
 
@@ -47,6 +47,7 @@ import numpy.ma as ma
 import pandas as pd
 import scipy.ndimage
 
+import xtgeo.interfaces.rms
 from xtgeo.common.constants import (
     UNDEF,
     UNDEF_LIMIT,
@@ -70,7 +71,6 @@ from . import (
     _regsurf_gridding,
     _regsurf_import,
     _regsurf_oper,
-    _regsurf_roxapi,
     _regsurf_utils,
 )
 
@@ -148,7 +148,7 @@ def surface_from_file(
     )
 
 
-def surface_from_roxar(
+def surface_from_rms(
     project,
     name,
     category,
@@ -156,11 +156,11 @@ def surface_from_roxar(
     realisation=0,
     dtype: Union[Type[np.float64], Type[np.float32]] = np.float64,
 ):
-    """This makes an instance of a RegularSurface directly from roxar input.
+    """This makes an instance of a RegularSurface directly from RMS input.
 
     Args:
         project (str or special): Name of project (as folder) if
-            outside RMS, og just use the magic project word if within RMS.
+            outside RMS, og just use the magic ``project`` word if within RMS.
         name (str): Name of surface/map
         category (str): For horizons/zones or clipboard/general2d_data:
             for example 'DS_extracted'. For clipboard/general2d_data this can
@@ -169,13 +169,14 @@ def surface_from_roxar(
         stype (str): RMS folder type, 'horizons' (default), 'zones', 'clipboard',
             'general2d_data' or 'trends'
         realisation (int): Realisation number, default is 0
-        dtype: Requested numpy dtype for array; default is 64 bit
+        dtype: Requested numpy dtype for array; default is 64 bit float. Note that down-
+            casting may give loss of precision.
 
     Example::
 
         # inside RMS:
         import xtgeo
-        mysurf = xtgeo.surface_from_roxar(project, 'TopEtive', 'DepthSurface')
+        mysurf = xtgeo.surface_from_rms(project, 'TopEtive', 'DepthSurface')
 
     Note::
 
@@ -187,8 +188,61 @@ def surface_from_roxar(
 
     """
 
-    return RegularSurface._read_roxar(
-        project, name, category, stype=stype, realisation=realisation, dtype=dtype
+    regsurf_rms = xtgeo.interfaces.rms.RegularSurfaceReader(
+        project_or_path=project,
+        name=name,
+        category=category,
+        stype=stype,
+        realisation=realisation,
+    ).load()
+
+    return RegularSurface(
+        name=regsurf_rms.name,
+        ncol=regsurf_rms.ncol,
+        nrow=regsurf_rms.nrow,
+        xori=regsurf_rms.xori,
+        yori=regsurf_rms.yori,
+        xinc=regsurf_rms.xinc,
+        yinc=regsurf_rms.yinc,
+        rotation=regsurf_rms.rotation,
+        values=regsurf_rms.values,
+        dtype=dtype,  # handled by constructor
+    )
+
+
+def surface_from_roxar(
+    project,
+    name,
+    category,
+    stype="horizons",
+    realisation=0,
+    dtype: Union[Type[np.float64], Type[np.float32]] = np.float64,
+):
+    """This makes an instance of a RegularSurface directly from roxar (i.e. RMS) input.
+
+    .. deprecated::
+        The `surface_from_roxar` function is deprecated and will be removed in a future
+        version. Use `surface_from_rms` instead.
+
+    For parameters and usage details, see :func:`surface_from_rms`.
+
+    """
+
+    # A pending deprecation warning will not show up in RMS for normal users
+    warnings.warn(
+        "The 'surface_from_roxar' function is deprecated and will be removed in a "
+        "future version. Use 'surface_from_rms' instead.",
+        PendingDeprecationWarning,
+        stacklevel=2,
+    )
+
+    return surface_from_rms(
+        project=project,
+        name=name,
+        category=category,
+        stype=stype,
+        realisation=realisation,
+        dtype=dtype,
     )
 
 
@@ -1149,87 +1203,63 @@ class RegularSurface:
         _regsurf_export.export_hdf5_regsurf(self, mfile, compression=compression)
         return mfile.file
 
-    @classmethod
-    def _read_roxar(
-        cls,
-        project,
-        name,
-        category,
-        stype="horizons",
-        realisation=0,
-        dtype=np.float64,
-    ):  # pragma: no cover
-        """Load a surface from a Roxar RMS project.
-
-        The import from the RMS project can be done either within the project
-        or outside the project.
-
-        Note that a shortform to::
-
-          import xtgeo
-          mysurf = xtgeo.surface_from_roxar(project, 'name', 'category')
-
-        Note also that horizon/zone name and category must exists in advance,
-        otherwise an Exception will be raised.
-
-        Args:
-            project (str or special): Name of project (as folder) if
-                outside RMS, og just use the magic project word if within RMS.
-            name (str): Name of surface/map
-            category (str): For horizons/zones or clipboard/general2d_data: for
-                example 'DS_extracted'
-            stype (str): RMS folder type, 'horizons' (default), 'zones' or 'clipboard'
-            realisation (int): Realisation number, default is 0
-            dtype: For supporting conversion to 32 bit float for the numpy; default
-                is 64 bit
-
-        """
-        kwargs = _regsurf_roxapi.import_horizon_roxapi(
-            project, name, category, stype, realisation
-        )
-        kwargs["dtype"] = dtype  # eventual dtype change will be done in __init__
-
-        return cls(**kwargs)
-
-    def to_roxar(
-        self, project, name, category, stype="horizons", realisation=0
-    ):  # pragma: no cover
-        """Store (export) a regular surface to a Roxar RMS project.
+    def to_rms(
+        self: RegularSurface,
+        project: object,
+        name: str,
+        category: str,
+        stype: Literal[
+            "horizons", "zones", "clipboard", "general2d_data", "trends"
+        ] = "horizons",
+        realisation: int = 0,
+        domain: Literal["depth", "time", "unknown"] = "depth",
+    ) -> None:  # pragma: no cover
+        """Store (export/save) a regular surface to a Roxar RMS project via the RMSAPI.
 
         The export to the RMS project can be done either within the project
-        or outside the project. The storing is done to the Horizons or the
-        Zones folder in RMS.
+        or outside the project. The storing can be done to various storage types in
+        RMS, such as 'Horizons', 'Zones', 'Clipboard', 'General2D_data' and
+        'Trends'.
 
         Note:
-            The horizon or zone name and category must exists in advance,
-            otherwise an Exception will be raised.
+            For stype = 'horizons' or 'zones', the horizon or zone name and category
+            must exists in advance, otherwise an Exception will be raised. Items on
+            'clipboard' and 'general2d_data' will be created if not already present,
+            and overwritten if they do.
 
-            When project is file path (direct access, outside RMS) then
-            ``to_roxar()`` will implicitly do a project save. Otherwise, the project
+            When project is a file path (direct access, outside RMS) then
+            ``to_rms()`` will implicitly do a project save. Otherwise, the project
             will not be saved until the user do an explicit project save action.
 
         Args:
-            project (str or special): Name of project (as folder) if
-                outside RMS, og just use the magic project word if within RMS.
-            name (str): Name of surface/map
-            category (str): Required for horizons/zones: e.g. 'DS_extracted'. For
-                clipboard/general2d_data is reperesent the folder(s), where "" or None
+            project: Name of project (as a folder string) if
+                outside RMS, or just use the magic ``project`` word if within RMS.
+            name: Name of surface/map
+            category: Required for horizons/zones: e.g. 'DS_extracted'. For
+                clipboard/general2d_data represents the folder(s), where "" or None
                 means no folder, while e.g. "myfolder/subfolder" means that folders
                 myfolder/subfolder will be created if not already present. For
                 stype = 'trends', the category will not be applied
-            stype (str): RMS folder type, 'horizons' (default), 'zones', 'clipboard'
+            stype: RMS storage type, 'horizons' (default), 'zones', 'clipboard'
                 'general2d_data', 'trends'
-            realisation (int): Realisation number, default is 0
+            realisation: Realisation number, default is 0
+            domain: Default is 'depth', but 'time', 'unknown' is also possible.
+                Note that domain only applies to stypes 'clipboard' and
+                'general2d_data', since the domain for horizons/zones is defined
+                more rigidly when the horizon/zone category is created in RMS.
+                Trends are always 'unknown' domain.
 
         Raises:
             ValueError: If name or category does not exist in the project
+            RuntimeError: If Roxar RMS API cannot store the surface for various reasons
 
-        Example:
-            Here the from_roxar method is used to initiate the object
+        Example::
+
+            Here the from_rms method is used to initiate the object
             directly::
 
               import xtgeo
-              topupperreek = xtgeo.surface_from_roxar(project, 'TopUpperReek',
+              topupperreek = xtgeo.surface_from_rms(project, 'TopUpperReek',
                                                     'DS_extracted')
               topupperreek.values += 200
 
@@ -1237,23 +1267,74 @@ class RegularSurface:
               topupperreek.to_file('topupperreek.gri')
 
               # store in project
-              topupperreek.to_roxar(project, 'TopUpperReek', 'DS_something')
+              topupperreek.to_rms(project, 'TopUpperReek', 'DS_something')
 
-        Note::
-
-            When dealing with surfaces to and from ``stype="trends"``, the surface must
-            exist in advance, i.e. the Roxar API do not allow creating new surfaces.
-            Actually trends are read only, but a workaround using ``load()`` in Roxar
-            API makes it possible to overwrite existing surface trends. In addition,
-            ``realisation`` is not applied in trends.
+        Note:
+            The ``realisation`` number is not applied in trends.
 
 
         .. versionadded:: 2.1 clipboard support
         .. versionadded:: 2.19 general2d_data and trends support
+        .. versionadded:: 4.14 Add domain keyword
 
         """
-        _regsurf_roxapi.export_horizon_roxapi(
-            self, project, name, category, stype, realisation
+        use_srf = self
+        if self.yflip == -1:
+            use_srf = self.copy()
+            use_srf.make_lefthanded()
+
+        data = xtgeo.interfaces.rms.RegularSurfaceDataRms(
+            name=name,
+            xori=use_srf.xori,
+            yori=use_srf.yori,
+            ncol=use_srf.ncol,
+            nrow=use_srf.nrow,
+            xinc=use_srf.xinc,
+            yinc=use_srf.yinc,
+            rotation=use_srf.rotation,
+            values=use_srf.values,  # exporter will enforce float64 and sanitize
+        )
+
+        writer = xtgeo.interfaces.rms.RegularSurfaceWriter(
+            project_or_path=project,
+            name=name,
+            category=category,
+            stype=stype,
+            realisation=realisation,
+            domain=domain,
+        )
+        writer.save(data)
+
+    def to_roxar(
+        self: RegularSurface,
+        project: object,
+        name: str,
+        category: str,
+        stype: str = "horizons",
+        realisation: int = 0,
+        domain: Literal["depth", "time", "unknown"] = "depth",
+    ) -> None:  # pragma: no cover
+        """Deprecated: Use to_rms() instead.
+
+        .. deprecated:: 4.15
+           ``to_roxar()`` is deprecated and will be removed in a future version.
+           Use :meth:`to_rms()` instead.
+        """
+        # a PendingDeprecationWarning will not show up for RMS users, which is intended
+        # since they should not be 'disturbed' by this change at this point.
+        warnings.warn(
+            "The 'to_roxar()' method is deprecated and will be removed in a later "
+            "xtgeo version. Use 'to_rms()' instead.",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+        self.to_rms(
+            project=project,
+            name=name,
+            category=category,
+            stype=stype,
+            realisation=realisation,
+            domain=domain,
         )
 
     @classmethod
@@ -1883,7 +1964,7 @@ class RegularSurface:
     # Operations restricted to inside/outside polygons
     # ==================================================================================
 
-    def operation_polygons(self, poly, value, opname="add", inside=True, _version=2):
+    def operation_polygons(self, poly, value, opname="add", inside=True):
         """A generic function for map operations inside or outside polygon(s).
 
         Args:
@@ -1895,14 +1976,9 @@ class RegularSurface:
                 on polygons (this key will be removed in later versions and shall not
                 be applied)
         """
-        if _version == 2:
-            _regsurf_oper.operation_polygons_v2(
-                self, poly, value, opname=opname, inside=inside
-            )
-        else:
-            _regsurf_oper.operation_polygons(
-                self, poly, value, opname=opname, inside=inside
-            )
+        _regsurf_oper.operation_polygons(
+            self, poly, value, opname=opname, inside=inside
+        )
 
     # shortforms
     def add_inside(self, poly, value):

xtgeo/well/_blockedwell_roxapi.py

@@ -1,5 +1,7 @@
 """Blocked Well input and output, private module for ROXAPI"""
 
+import warnings
+
 import numpy as np
 import numpy.ma as npma
 import pandas as pd
@@ -191,7 +193,6 @@ def _roxapi_export_bwell(self, rox, gname, bwname, wname, lognames, ijk, realisa
         else:
             bwlog = bwprops[lname]
             bwprop = bwlog.get_values(realisation=realisation)
-
         usedtype = bwprop.dtype
         dind = bwset.get_data_indices([self._wname], realisation=realisation)
 
@@ -199,9 +200,28 @@ def _roxapi_export_bwell(self, rox, gname, bwname, wname, lognames, ijk, realisa
             raise ValueError(
                 "Dataframe is of wrong size, changing numbers of rows is not possible"
             )
-        maskedvalues = np.ma.masked_invalid(
-            self.get_dataframe(copy=False)[lname].values
-        ).astype(usedtype)
+
+        # Get the values
+        values = self.get_dataframe(copy=False)[lname].values
+
+        # Create masked array first, then handle casting
+        masked_values = np.ma.masked_invalid(values)
+
+        # Handle casting based on target type
+        if np.issubdtype(usedtype, np.integer):
+            # For integer types, suppress the warning and handle invalid values
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore", "invalid value encountered in cast", RuntimeWarning
+                )
+                # Fill masked values with a valid integer before casting
+                filled_values = np.ma.filled(masked_values, fill_value=0)
+                cast_values = filled_values.astype(usedtype)
+                # Recreate the masked array with the original mask
+                maskedvalues = np.ma.masked_array(cast_values, mask=masked_values.mask)
+        else:
+            # For float types, direct cast is fine
+            maskedvalues = masked_values.astype(usedtype)
 
         # there are cases where the RMS API complains on the actual value of the masked
         # array being outside range; hence remedy is to set 'data' value to a usedtype

xtgeo/xyz/_xyz_io.py

@@ -288,15 +288,17 @@ def import_rms_attr(pfile, zname="Z_TVDSS"):
         names=names,
         dtype=dtypes,
     )
+
     for col in dfr.columns[3:]:
         if col in _attrs:
-            # pandas gives a FutureWarning here due to casting what was
-            # previously a string to a float/int.
+            # avoid FutureWarning by not using .replace() for mixed dtypes
             if _attrs[col] == "float":
-                dfr[col] = dfr[col].replace("UNDEF", UNDEF).astype(float)
+                s = dfr[col].mask(dfr[col] == "UNDEF", UNDEF)
+                dfr[col] = pd.to_numeric(s, errors="coerce").astype(float)
             elif _attrs[col] == "int":
-                dfr[col] = dfr[col].replace("UNDEF", UNDEF_INT).astype(int)
-
+                s = dfr[col].mask(dfr[col] == "UNDEF", UNDEF_INT)
+                s = pd.to_numeric(s, errors="coerce").fillna(UNDEF_INT).astype(int)
+                dfr[col] = s
         # cast to numerical if possible
         with contextlib.suppress(ValueError, TypeError):
             dfr[col] = pd.to_numeric(dfr[col])

xtgeo/xyz/points.py

@@ -504,6 +504,7 @@ class Points(XYZ):
             "Direct access to the dataframe property in Points class will be "
             "deprecated in xtgeo 5.0. Use `get_dataframe()` instead.",
             PendingDeprecationWarning,
+            stacklevel=2,
         )
         return self._df
 

{xtgeo-4.10.1.dist-info → xtgeo-4.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xtgeo
-Version: 4.10.1
+Version: 4.14.0
 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
@@ -51,6 +50,7 @@ Requires-Dist: coverage>=4.1; extra == "dev"
 Requires-Dist: hypothesis; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
 Requires-Dist: pydocstyle; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-benchmark; extra == "dev"
@@ -92,7 +92,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