xtgeo 4.14.0__cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/surface/surfaces.py

@@ -0,0 +1,276 @@
+"""The surfaces module, which has the Surfaces class (collection of surface objects)."""
+
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+import numpy as np
+
+from xtgeo.common.log import null_logger
+from xtgeo.common.xtgeo_dialog import XTGDescription, XTGeoDialog
+
+from . import _surfs_import
+from .regular_surface import RegularSurface, surface_from_file
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+
+def surfaces_from_grid(grid, subgrids=True, rfactor=1):
+    surf, subtype, order = _surfs_import.from_grid3d(grid, subgrids, rfactor)
+    return Surfaces(surfaces=surf, subtype=subtype, order=order)
+
+
+class Surfaces:
+    """Class for a collection of Surface objects, for operations that involves
+    a number of surfaces, such as statistical numbers.
+
+    A collection of surfaces can be different things:
+
+    * A list if surfaces in stratigraphic order
+    * A collection of different realisations of the same surface
+    * A collection of isochores
+
+    Args:
+        input (list, optional): A list of XTGeo objects and/or file names)
+        subtype (str): "tops", "isochores", or None (default)
+        order (str): Assummed order: "same", "stratigraphic", None(default)
+
+    .. seealso::
+       Class :class:`~xtgeo.surface.regular_surface.RegularSurface` class.
+
+    .. versionadded:: 2.1
+    """
+
+    def __init__(
+        self,
+        surfaces: list[RegularSurface] | None = None,
+        subtype: Literal["tops", "isochores"] | None = None,
+        order: Literal["same", "stratigraphic"] | None = None,
+    ):
+        self._surfaces = []
+        if surfaces is not None:
+            self.append(surfaces)
+        self._subtype = subtype
+        self._order = order
+
+    @property
+    def surfaces(self):
+        """Get or set a list of individual surfaces"""
+        return self._surfaces
+
+    @surfaces.setter
+    def surfaces(self, slist):
+        if not isinstance(slist, list):
+            raise ValueError("Input not a list")
+
+        for elem in slist:
+            if not isinstance(elem, RegularSurface):
+                raise ValueError("Element in list not a valid type of Surface")
+
+        self._surfaces = slist
+
+    def append(self, input: list[RegularSurface] | list[str] | RegularSurface) -> None:
+        """Append surface(s) from a RegularSurface or a list of objects or files.
+
+        Args:
+            input: A single RegularSurface, or list of RegularSurface objects and/or
+                file names.
+        """
+        if isinstance(input, RegularSurface):
+            self.surfaces.append(input)
+            return
+
+        if not isinstance(input, list):
+            raise ValueError("Input not a list or a RegularSurface object.")
+
+        for item in input:
+            if isinstance(item, RegularSurface):
+                self.surfaces.append(item)
+            else:
+                try:
+                    sobj = surface_from_file(item, fformat="guess")
+                    self.surfaces.append(sobj)
+                except OSError:
+                    xtg.warnuser(f"Cannot read as file, skip: {item}")
+
+    def describe(self, flush=True):
+        """Describe an instance by printing to stdout"""
+
+        dsc = XTGDescription()
+        dsc.title(f"Description of {self.__class__.__name__} instance")
+        dsc.txt("Object ID", id(self))
+
+        for inum, surf in enumerate(self.surfaces):
+            dsc.txt("Surface:", inum, surf.name)
+
+        if flush:
+            dsc.flush()
+            return None
+
+        return dsc.astext()
+
+    def copy(self):
+        """Copy a Surfaces instance to a new unique instance (a deep copy)."""
+
+        new = Surfaces()
+
+        for surf in self._surfaces:
+            newsurf = surf.copy()
+            new._surfaces.append(newsurf)
+
+        new._order = self._order
+        new._subtype = self._subtype
+
+        return new
+
+    def get_surface(self, name):
+        """Get a RegularSurface() instance by name, or return None if name not found"""
+
+        logger.info("Asking for a surface with name %s", name)
+        for surf in self._surfaces:
+            if surf.name == name:
+                return surf
+        return None
+
+    def apply(self, func, *args, **kwargs):
+        """Apply a function to the Surfaces array.
+
+        The return value of the function (numpy nan comptatible) will be a
+        numpy array of the same shape as the first surface.
+
+        E.g. surfs.apply(np.nanmean, axis=0) will return the mean surface.
+
+        Args:
+            func: Function to apply, e.g. np.nanmean
+            args: The function arguments
+            kwargs: The function keyword arguments
+
+        Raises:
+            ValueError: If surfaces differ in topology.
+
+        """
+        template = self.surfaces[0].copy()
+        slist = []
+        for surf in self.surfaces:
+            status = template.compare_topology(surf, strict=False)
+            if not status:
+                raise ValueError("Cannot do statistics, surfaces differ in topology")
+            slist.append(np.ma.filled(surf.values, fill_value=np.nan))
+
+        xlist = np.array(slist)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", r"All-NaN (slice|axis) encountered")
+            template.values = func(xlist, *args, **kwargs)
+
+        return template
+
+    def statistics(self, percentiles=None):
+        """Return statistical measures from the surfaces.
+
+        The statistics returned is:
+        * mean: the arithmetic mean surface
+        * std: the standard deviation surface (where ddof = 1)
+        * percentiles: on demand (such operations may be slow)
+
+        Currently this function expects that the surfaces all have the same
+        shape/topology.
+
+        Args:
+            percentiles (list of float): If defined, a list of perecentiles to evaluate
+                e.g. [10, 50, 90] for p10, p50, p90
+
+        Returns:
+            dict: A dictionary of statistical measures, see list above
+
+        Raises:
+            ValueError: If surfaces differ in topology.
+
+        Example::
+
+            surfs = Surfaces(mylist)  # mylist is a collection of files
+            stats = surfs.statistics()
+            # export the mean surface
+            stats["mean"].to_file("mymean.gri")
+
+        .. versionchanged:: 2.13 Added `percentile`
+        """
+        result = {}
+
+        template = self.surfaces[0].copy()
+
+        slist = []
+        for surf in self.surfaces:
+            status = template.compare_topology(surf, strict=False)
+            if not status:
+                raise ValueError("Cannot do statistics, surfaces differ in topology")
+            slist.append(np.ma.filled(surf.values, fill_value=np.nan).ravel())
+
+        xlist = np.array(slist)
+
+        template.values = np.ma.masked_invalid(xlist).mean(axis=0)
+        result["mean"] = template.copy()
+        template.values = np.ma.masked_invalid(xlist).std(axis=0, ddof=1)
+        result["std"] = template.copy()
+
+        if percentiles is not None:
+            # nan on a axis tends to give warnings that are not a worry; suppress:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", r"All-NaN (slice|axis) encountered")
+                res = np.nanpercentile(xlist, percentiles, axis=0)
+
+            for slice, prc in enumerate(percentiles):
+                template.values = res[slice, :]
+                result["p" + str(prc)] = template.copy()
+                if prc == 50:
+                    result["median"] = result["p50"]
+
+        return result
+
+    def is_depth_consistent(self) -> bool:
+        """Check that surfaces are depth consistent, i.e. not crossing each other."""
+        previous = self.surfaces[0]
+        for surf in self.surfaces[1:]:
+            ok_topology = previous.compare_topology(surf, strict=True)
+            if not ok_topology:
+                raise ValueError(
+                    "Cannot check if surfaces are depth consistent, surfaces differ "
+                    "in topology (definitions of origin, shape, etc.)"
+                )
+
+            diff = surf - previous
+            if np.any(diff.values < 0):
+                return False
+            previous = surf
+        return True
+
+    def make_depth_consistent(self, inplace: bool = True) -> Surfaces | None:
+        """Make surfaces depth consistent, i.e. not crossing each other.
+
+        The algorithm is starting with top surface and iteratively adjust
+        the surface below to be consistent with the previous surface.
+
+        Args:
+            inplace: If True (default), the object is changed in-place, if False,
+                a new object is returned.
+        """
+        logger.debug("Make surfaces depth consistent (in-place=%s)", inplace)
+
+        surfs = self.copy() if not inplace else self
+
+        previous = surfs.surfaces[0]
+        for surf in surfs.surfaces[1:]:
+            ok_topology = previous.compare_topology(surf, strict=True)
+            if not ok_topology:
+                raise ValueError(
+                    "Cannot make surfaces depth consistent, surfaces differ in "
+                    "topology (definitions of origin, shape, etc.)"
+                )
+
+            surf.values = np.where(
+                surf.values < previous.values, previous.values, surf.values
+            )
+            previous = surf
+        return surfs if not inplace else None

xtgeo/well/__init__.py

@@ -0,0 +1,24 @@
+"""The XTGeo well package"""
+
+from .blocked_well import BlockedWell, blockedwell_from_file, blockedwell_from_roxar
+from .blocked_wells import (
+    BlockedWells,
+    blockedwells_from_files,
+    blockedwells_from_roxar,
+)
+from .well1 import Well, well_from_file, well_from_roxar
+from .wells import Wells, wells_from_files
+
+__all__ = [
+    "BlockedWell",
+    "blockedwell_from_file",
+    "blockedwell_from_roxar",
+    "BlockedWells",
+    "blockedwells_from_files",
+    "blockedwells_from_roxar",
+    "Well",
+    "well_from_file",
+    "well_from_roxar",
+    "Wells",
+    "wells_from_files",
+]

xtgeo/well/_blockedwell_roxapi.py

@@ -0,0 +1,241 @@
+"""Blocked Well input and output, private module for ROXAPI"""
+
+import warnings
+
+import numpy as np
+import numpy.ma as npma
+import pandas as pd
+
+from xtgeo.common._xyz_enum import _AttrName, _AttrType
+from xtgeo.common.constants import INT_MIN
+from xtgeo.common.exceptions import WellNotFoundError
+from xtgeo.common.log import null_logger
+from xtgeo.roxutils import RoxUtils
+from xtgeo.roxutils._roxar_loader import roxar
+
+logger = null_logger(__name__)
+
+
+# Import / export via ROX/RMS api
+
+
+def import_bwell_roxapi(
+    self, project, gname, bwname, wname, lognames=None, ijk=True, realisation=0
+):
+    """Private function for loading project and ROXAPI blockwell import"""
+
+    logger.debug("Opening RMS project ...")
+    rox = RoxUtils(project, readonly=True)
+
+    _roxapi_import_bwell(self, rox, gname, bwname, wname, lognames, ijk, realisation)
+
+    rox.safe_close()
+
+
+def export_bwell_roxapi(
+    self, project, gname, bwname, wname, lognames="all", ijk=False, realisation=0
+):
+    """Private function for blockwell export (store in RMS) from XTGeo to RoxarAPI"""
+
+    logger.debug("Opening RMS project ...")
+    rox = RoxUtils(project, readonly=False)
+
+    _roxapi_export_bwell(self, rox, gname, bwname, wname, lognames, ijk, realisation)
+
+    if rox._roxexternal:
+        rox.project.save()
+
+    rox.safe_close()
+
+
+def _roxapi_import_bwell(
+    self,
+    rox,
+    gname,
+    bwname,
+    wname,
+    lognames,
+    ijk,
+    realisation,
+):
+    """Private function for ROXAPI well import (get well from Roxar)"""
+
+    if gname in rox.project.grid_models:
+        gmodel = rox.project.grid_models[gname]
+        logger.debug("RMS grid model <%s> OK", gname)
+    else:
+        raise ValueError(f"No such grid name present: {gname}")
+
+    if bwname in gmodel.blocked_wells_set:
+        bwset = gmodel.blocked_wells_set[bwname]
+        logger.debug("Blocked well set <%s> OK", bwname)
+    else:
+        raise ValueError(f"No such blocked well set: {bwname}")
+
+    if wname in bwset.get_well_names(realisation=realisation):
+        self._wname = wname
+    else:
+        raise WellNotFoundError(f"No such well in blocked well set: {wname}")
+
+    bwprops = list(bwset.properties)
+    bwnames = [item.name for item in bwset.properties]
+
+    bw_cellindices = bwset.get_cell_numbers(realisation=realisation)
+    dind = bwset.get_data_indices([wname], realisation=realisation)
+
+    cind = bw_cellindices[dind]
+    xyz = np.transpose(gmodel.get_grid(realisation=realisation).get_cell_centers(cind))
+
+    logs = {}
+    logs[_AttrName.XNAME.value] = xyz[0].astype(np.float64)
+    logs[_AttrName.YNAME.value] = xyz[1].astype(np.float64)
+    logs[_AttrName.ZNAME.value] = xyz[2].astype(np.float64)
+
+    if ijk:
+        ijk = np.transpose(
+            gmodel.get_grid(realisation=realisation).grid_indexer.get_indices(cind)
+        )
+        logs[_AttrName.I_INDEX.value] = ijk[0].astype(np.float64)
+        logs[_AttrName.J_INDEX.value] = ijk[1].astype(np.float64)
+        logs[_AttrName.K_INDEX.value] = ijk[2].astype(np.float64)
+
+    usenames = []
+    if lognames and lognames == "all":
+        usenames = bwnames
+    elif lognames:
+        usenames = lognames
+
+    for bwprop in bwprops:
+        lname = bwprop.name
+        if lname not in usenames:
+            continue
+        propvalues = bwprop.get_values(realisation=realisation)
+        tmplog = propvalues[dind].astype(np.float64)
+        tmplog = npma.filled(tmplog, fill_value=np.nan)
+        tmplog[tmplog == -999] = np.nan
+        if "discrete" in str(bwprop.type):
+            self.create_log(
+                lname, logtype=_AttrType.DISC.value, logrecord=bwprop.code_names
+            )
+        else:
+            self.create_log(lname, logtype=_AttrType.CONT.value)
+
+        logs[lname] = tmplog
+
+    self.set_dataframe(pd.DataFrame.from_dict(logs))
+    self._gridname = gname
+    self._filesrc = None
+
+    # finally get some other metadata like RKB and topside X Y; as they
+    # seem to miss for the BW in RMS, try and get them from the
+    # well itself...
+
+    if wname in rox.project.wells:
+        self._rkb = rox.project.wells[wname].rkb
+        self._xpos, self._ypos = rox.project.wells[wname].wellhead
+    else:
+        self._rkb = None
+        self._xpos, self._ypos = (
+            self._df[_AttrName.XNAME.value][0],
+            self._df[_AttrName.YNAME.value][0],
+        )
+
+
+def _roxapi_export_bwell(self, rox, gname, bwname, wname, lognames, ijk, realisation):
+    """Private function for ROXAPI well export (set well with updated logs to Roxar)"""
+
+    if gname in rox.project.grid_models:
+        gmodel = rox.project.grid_models[gname]
+        logger.debug("RMS grid model <%s> OK", gname)
+    else:
+        raise ValueError(f"No such grid name present: {gname}")
+
+    if bwname in gmodel.blocked_wells_set:
+        bwset = gmodel.blocked_wells_set[bwname]
+        logger.debug("Blocked well set <%s> OK", bwname)
+        bwprops = bwset.properties
+    else:
+        raise ValueError(f"No such blocked well set: {bwname}")
+
+    if wname in bwset.get_well_names(realisation=realisation):
+        self._wname = wname
+    else:
+        raise WellNotFoundError(f"No such well in blocked well set: {wname}")
+
+    bwnames = [item.name for item in bwset.properties]  # updated list
+
+    # get the current indices for the well
+    dind = bwset.get_data_indices([self._wname], realisation=realisation)
+
+    for lname in self.lognames:
+        if not ijk and lname in [
+            _AttrName.I_INDEX.value,
+            _AttrName.J_INDEX.value,
+            _AttrName.K_INDEX.value,
+        ]:
+            continue
+
+        if lognames != "all" and lname not in lognames:
+            continue
+
+        if lname not in bwnames:
+            if self.wlogtypes[lname] == _AttrType.CONT.value:
+                bwlog = bwset.properties.create(
+                    lname, roxar.GridPropertyType.continuous, np.float32
+                )
+                bwprop = bwset.generate_values(discrete=False, fill_value=0.0)
+            else:
+                bwlog = bwset.properties.create(
+                    lname, roxar.GridPropertyType.discrete, np.int32
+                )
+                bwprop = bwset.generate_values(discrete=True, fill_value=0)
+
+        else:
+            bwlog = bwprops[lname]
+            bwprop = bwlog.get_values(realisation=realisation)
+        usedtype = bwprop.dtype
+        dind = bwset.get_data_indices([self._wname], realisation=realisation)
+
+        if self.get_dataframe(copy=False)[lname].values.size != dind.size:
+            raise ValueError(
+                "Dataframe is of wrong size, changing numbers of rows is not possible"
+            )
+
+        # 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
+        # dependent 'undef'. Hpwever still some flaky stuff here...
+        undef = INT_MIN if "int" in str(usedtype) else np.nan
+        maskedvalues.data[maskedvalues.mask] = undef
+
+        bwprop[dind] = maskedvalues
+        try:
+            bwlog.set_values(bwprop, realisation=realisation)
+        except ValueError as err:
+            msg = (
+                f"\nFailed setting blocked log for {lname} in RMS.\n"
+                f"Details:\n{maskedvalues.data}\n{maskedvalues.mask}\n{usedtype}"
+            )
+            logger.critical(msg)
+            raise err

xtgeo/well/_blockedwells_roxapi.py

@@ -0,0 +1,68 @@
+"""Well input and output, private module for ROXAPI"""
+
+from xtgeo.common.log import null_logger
+from xtgeo.common.xtgeo_dialog import XTGeoDialog
+from xtgeo.roxutils import RoxUtils
+
+from .blocked_well import blockedwell_from_roxar
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+
+# Import from ROX api
+# --------------------------------------------------------------------------------------
+def import_bwells_roxapi(
+    self, project, gname, bwname, lognames=None, ijk=True, realisation=0
+):  # pragma: no cover
+    """Private function for loading project and ROXAPI blockwell import"""
+
+    logger.debug("Opening RMS project ...")
+    rox = RoxUtils(project, readonly=True)
+
+    _roxapi_import_bwells(self, rox, gname, bwname, lognames, ijk, realisation)
+
+    rox.safe_close()
+
+
+def _roxapi_import_bwells(
+    self, rox, gname, bwname, lnames, ijk, realisation
+):  # pragma: no cover
+    """Private function for ROXAPI blocked wells import"""
+
+    if gname in rox.project.grid_models:
+        gmodel = rox.project.grid_models[gname]
+        logger.debug("RMS grid model <%s> OK", gname)
+    else:
+        raise ValueError(f"No such grid name present: {gname}")
+
+    if bwname in gmodel.blocked_wells_set:
+        bwset = gmodel.blocked_wells_set[bwname]
+        logger.debug("Blocked well set <%s> OK", bwname)
+    else:
+        raise ValueError(f"No such blocked well set: {bwname}")
+
+    wnames = bwset.get_well_names()
+
+    logger.debug("Lognames are %s", lnames)
+
+    bwlist = []
+    logger.debug("Loading wells ...")
+    for wname in wnames:
+        logger.debug("Loading well %s", wname)
+        bwtmp = blockedwell_from_roxar(
+            rox.project,
+            gname,
+            bwname,
+            wname,
+            lognames=lnames,
+            ijk=ijk,
+            realisation=realisation,
+        )
+        bwlist.append(bwtmp)
+
+    self._wells = bwlist
+
+    if not self._wells:
+        xtg.warn("No wells imported to BlockedWells")
+        self._wells = None

xtgeo/well/_well_aux.py

@@ -0,0 +1,30 @@
+"""Auxillary functions for the well class
+
+'self' is a Well() instance
+
+"""
+
+from __future__ import annotations
+
+from xtgeo.common.exceptions import InvalidFileFormatError
+from xtgeo.common.log import null_logger
+from xtgeo.io._file import FileFormat
+
+from . import _well_io
+
+logger = null_logger(__name__)
+
+
+def _data_reader_factory(file_format: FileFormat):
+    if file_format in (FileFormat.RMSWELL, FileFormat.IRAP_ASCII):
+        return _well_io.import_rms_ascii
+    if file_format == FileFormat.HDF:
+        return _well_io.import_hdf5_well
+
+    extensions = FileFormat.extensions_string(
+        [FileFormat.RMSWELL, FileFormat.IRAP_ASCII, FileFormat.HDF]
+    )
+    raise InvalidFileFormatError(
+        f"File format {file_format} is invalid for Well types. "
+        f"Supported formats are {extensions}."
+    )