xtgeo 4.8.0__cp313-cp313-macosx_11_0_arm64.whl

xtgeo/surface/_regsurf_roxapi.py

@@ -0,0 +1,241 @@
+# coding: utf-8
+"""Roxar API functions for XTGeo RegularSurface."""
+
+import os
+import tempfile
+
+import numpy as np
+
+from xtgeo.common.log import null_logger
+from xtgeo.roxutils import RoxUtils
+from xtgeo.roxutils._roxar_loader import roxar
+
+logger = null_logger(__name__)
+
+VALID_STYPES = ["horizons", "zones", "clipboard", "general2d_data", "trends"]
+
+
+def _check_stypes_names_category(roxutils, stype, name, category):
+    """General check of some input values."""
+    stype = stype.lower()
+
+    if stype not in VALID_STYPES:
+        raise ValueError(
+            f"Given stype {stype} is not supported, legal stypes are: {VALID_STYPES}"
+        )
+
+    if not name:
+        raise ValueError("The name is missing or empty.")
+
+    if stype in ("horizons", "zones") and (name is None or not category):
+        raise ValueError(
+            "Need to spesify both name and category for horizons and zones"
+        )
+
+    if stype == "general2d_data" and not roxutils.version_required("1.6"):
+        raise NotImplementedError(
+            "API Support for general2d_data is missing in this RMS version"
+            f"(current API version is {roxutils.roxversion} - required is 1.6"
+        )
+
+
+def import_horizon_roxapi(
+    project, name, category, stype, realisation
+):  # pragma: no cover
+    """Import a Horizon surface via ROXAR API spec. to xtgeo."""
+    roxutils = RoxUtils(project, readonly=True)
+
+    _check_stypes_names_category(roxutils, stype, name, category)
+
+    proj = roxutils.project
+    args = _roxapi_import_surface(proj, name, category, stype, realisation)
+
+    roxutils.safe_close()
+    return args
+
+
+def _roxapi_import_surface(
+    proj, name, category, stype, realisation
+):  # pragma: no cover
+    args = {}
+    args["name"] = name
+
+    if stype == "horizons":
+        if name not in proj.horizons:
+            raise ValueError(f"Name {name} is not within Horizons")
+        if category not in proj.horizons.representations:
+            raise ValueError(f"Category {category} is not within Horizons categories")
+        try:
+            rox = proj.horizons[name][category].get_grid(realisation)
+            args.update(_roxapi_horizon_to_xtgeo(rox))
+        except KeyError as kwe:
+            logger.error(kwe)
+
+    elif stype == "zones":
+        if name not in proj.zones:
+            raise ValueError(f"Name {name} is not within Zones")
+        if category not in proj.zones.representations:
+            raise ValueError(f"Category {category} is not within Zones categories")
+        try:
+            rox = proj.zones[name][category].get_grid(realisation)
+            args.update(_roxapi_horizon_to_xtgeo(rox))
+        except KeyError as kwe:
+            logger.error(kwe)
+
+    elif stype in ("clipboard", "general2d_data"):
+        styperef = getattr(proj, stype)
+        if category:
+            folders = category.split("|" if "|" in category else "/")
+            rox = styperef.folders[folders]
+        else:
+            rox = styperef
+
+        roxsurf = rox[name].get_grid(realisation)
+        args.update(_roxapi_horizon_to_xtgeo(roxsurf))
+
+    elif stype == "trends":
+        if name not in proj.trends.surfaces:
+            logger.info("Name %s is not present in trends", name)
+            raise ValueError(f"Name {name} is not within Trends")
+        rox = proj.trends.surfaces[name]
+
+        roxsurf = rox.get_grid(realisation)
+        args.update(_roxapi_horizon_to_xtgeo(roxsurf))
+
+    else:
+        raise ValueError(f"Invalid stype given: {stype}")  # should never reach here
+    return args
+
+
+def _roxapi_horizon_to_xtgeo(rox):  # pragma: no cover
+    """Tranforming surfaces from ROXAPI to XTGeo object."""
+    # local function
+    args = {}
+    logger.info("Surface from roxapi to xtgeo...")
+    args["xori"], args["yori"] = rox.origin
+    args["ncol"], args["nrow"] = rox.dimensions
+    args["xinc"], args["yinc"] = rox.increment
+    args["rotation"] = rox.rotation
+
+    args["values"] = rox.get_values()
+    logger.info("Surface from roxapi to xtgeo... DONE")
+    return args
+
+
+def export_horizon_roxapi(
+    self, project, name, category, stype, realisation
+):  # pragma: no cover
+    """Export (store) a Horizon surface to RMS via ROXAR API spec."""
+    roxutils = RoxUtils(project, readonly=False)
+
+    _check_stypes_names_category(roxutils, stype, name, category)
+
+    logger.info("Surface from xtgeo to roxapi...")
+    use_srf = self.copy()  # avoid modifying the original instance
+    if self.yflip == -1:
+        # roxar API cannot handle negative increments
+        use_srf.swapaxes()
+
+    use_srf.values = use_srf.values.astype(np.float64)
+
+    # Note that the RMS api does NOT accepts NaNs or Infs, even if behind the mask(!),
+    # so we need to replace them with some other value
+    if np.isnan(use_srf.values.data).any() or np.isinf(use_srf.values.data).any():
+        logger.warning(
+            "NaNs or Infs detected in the surface, replacing fill_value "
+            "prior to RMS API usage."
+        )
+        applied_fill_value = np.finfo(np.float64).max  # aka 1.7976931348623157e+308
+        all_values = np.ma.filled(use_srf.values, fill_value=applied_fill_value)
+        # replace nan in all_values with applied_fill_value
+        all_values = np.where(
+            np.isnan(all_values) | np.isinf(all_values), applied_fill_value, all_values
+        )
+        # now remask the array; NB! use _values to avoid the mask being reset
+        use_srf._values = np.ma.masked_equal(all_values, applied_fill_value)
+
+    _roxapi_export_surface(
+        use_srf, roxutils.project, name, category, stype, realisation
+    )
+
+    if roxutils._roxexternal:
+        roxutils.project.save()
+
+    logger.info("Surface from xtgeo to roxapi... DONE")
+    roxutils.safe_close()
+
+
+def _roxapi_export_surface(
+    self, proj, name, category, stype, realisation
+):  # pragma: no cover
+    if stype == "horizons":
+        if name not in proj.horizons:
+            raise ValueError(f"Name {name} is not within Horizons")
+        if category not in proj.horizons.representations:
+            raise ValueError(f"Category {category} is not within Horizons categories")
+        try:
+            roxroot = proj.horizons[name][category]
+            roxg = _xtgeo_to_roxapi_grid(self)
+            roxg.set_values(self.values)
+            roxroot.set_grid(roxg, realisation=realisation)
+        except KeyError as kwe:
+            logger.error(kwe)
+
+    elif stype == "zones":
+        if name not in proj.zones:
+            raise ValueError(f"Name {name} is not within Zones")
+        if category not in proj.zones.representations:
+            raise ValueError(f"Category {category} is not within Zones categories")
+        try:
+            roxroot = proj.zones[name][category]
+            roxg = _xtgeo_to_roxapi_grid(self)
+            roxg.set_values(self.values)
+            roxroot.set_grid(roxg)
+        except KeyError as kwe:
+            logger.error(kwe)
+
+    elif stype in ("clipboard", "general2d_data"):
+        folders = []
+        if category:
+            folders = category.split("|" if "|" in category else "/")
+        styperef = getattr(proj, stype)
+        if folders:
+            styperef.folders.create(folders)
+
+        roxroot = styperef.create_surface(name, folders)
+        roxg = _xtgeo_to_roxapi_grid(self)
+        roxg.set_values(self.values)
+        roxroot.set_grid(roxg)
+
+    elif stype == "trends":
+        if name not in proj.trends.surfaces:
+            logger.info("Name %s is not present in trends", name)
+            raise ValueError(
+                f"Name {name} is not within Trends (it must exist in advance!)"
+            )
+        # here a workound; trends.surfaces are read-only in Roxar API, but is seems
+        # that load() in RMS is an (undocumented?) workaround...
+
+        roxsurf = proj.trends.surfaces[name]
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logger.info("Made a tmp folder: %s", tmpdir)
+            self.to_file(os.path.join(tmpdir, "gxx.gri"), fformat="irap_binary")
+
+            roxsurf.load(os.path.join(tmpdir, "gxx.gri"), roxar.FileFormat.ROXAR_BINARY)
+
+    else:
+        raise ValueError(f"Invalid stype given: {stype}")  # should never reach here
+
+
+def _xtgeo_to_roxapi_grid(self):  # pragma: no cover
+    # Create a 2D grid
+
+    return roxar.RegularGrid2D.create(
+        x_origin=self.xori,
+        y_origin=self.yori,
+        i_inc=self.xinc,
+        j_inc=self.yinc,
+        ni=self.ncol,
+        nj=self.nrow,
+        rotation=self.rotation,
+    )

xtgeo/surface/_regsurf_utils.py

@@ -0,0 +1,81 @@
+"""RegularSurface utilities"""
+
+import numpy as np
+
+from xtgeo.common.calc import _swap_axes
+from xtgeo.common.constants import UNDEF
+from xtgeo.common.log import null_logger
+
+logger = null_logger(__name__)
+
+
+def swapaxes(self):
+    """Swap the axes columns vs rows, keep origin. Will change yflip."""
+    self._rotation, self._yflip, swapped_values = _swap_axes(
+        self._rotation,
+        self._yflip,
+        values=self.values.filled(UNDEF),
+    )
+    self._ncol, self._nrow = self._nrow, self._ncol
+    self._xinc, self._yinc = self._yinc, self._xinc
+    self.values = swapped_values["values"]
+
+
+def make_lefthanded(self):
+    """Will rearrange in case of right-handed system, ie. yflip = -1.
+
+    In contrasts to swapaxes(), this will change the origin.
+    """
+    if self.yflip == -1 or self.yinc < 0:
+        self._xori, self._yori, _ = self.get_xy_value_from_ij(1, self.nrow)
+        self._yflip = 1
+        self._yinc = abs(self.yinc)
+
+        # the values shall be reversed along the last axis
+        self._values = self._values[:, ::-1]
+        self._xlines = self._xlines[::-1]
+
+
+def make_righthanded(self):
+    """Will rearrange in case of left-handed system, ie. yflip = 1.
+
+    In contrasts to swapaxes(), this will change the origin.
+    """
+    if self.yflip == 1 or self.yinc > 0:
+        self._xori, self._yori, _ = self.get_xy_value_from_ij(1, self.nrow)
+        self._yflip = -1
+        self._yinc = -1 * abs(self.yinc)
+
+        # the values shall be reversed along the last axis
+        self._values = self._values[:, ::-1]
+        self._xlines = self._xlines[::-1]
+
+
+def autocrop(self):
+    """Crop surface by looking at undefined areas, update instance"""
+
+    minvalue = self.values.min()
+
+    if np.isnan(minvalue):
+        return
+
+    arrx, arry = np.ma.where(self.values >= minvalue)
+
+    imin = int(arrx.min())
+    imax = int(arrx.max())
+
+    jmin = int(arry.min())
+    jmax = int(arry.max())
+
+    xori, yori, _dummy = self.get_xy_value_from_ij(imin + 1, jmin + 1)
+
+    ncol = imax - imin + 1
+    nrow = jmax - jmin + 1
+
+    self._values = self.values[imin : imax + 1, jmin : jmax + 1]
+    self._ilines = self.ilines[imin : imax + 1]
+    self._xlines = self.xlines[jmin : jmax + 1]
+    self._ncol = ncol
+    self._nrow = nrow
+    self._xori = xori
+    self._yori = yori

xtgeo/surface/_surfs_import.py

@@ -0,0 +1,43 @@
+"""Import multiple surfaces"""
+
+from xtgeo.common.log import null_logger
+
+from .regular_surface import surface_from_grid3d
+
+logger = null_logger(__name__)
+
+
+def from_grid3d(grid, subgrids, rfactor):
+    """Get surfaces, subtype and order from 3D grid, including subgrids"""
+
+    logger.info("Extracting surface from 3D grid...")
+
+    # determine layers
+    layers = []
+    names = []
+    if subgrids and grid.subgrids is not None:
+        last = ""
+        for sgrd, srange in grid.subgrids.items():
+            layers.append(str(srange[0]) + "_top")
+            names.append(sgrd + "_top")
+            last = str(srange[-1])
+            lastname = sgrd
+        # base of last layer
+        layers.append(last + "_base")
+        names.append(lastname + "_base")
+    else:
+        layers.append("top")
+        names.append("top")
+        layers.append("base")
+        names.append("base")
+
+    # next extract these layers
+    layerstack = []
+    for inum, lay in enumerate(layers):
+        layer = surface_from_grid3d(grid, template=None, where=lay, rfactor=rfactor)
+        layer.name = names[inum]
+        layerstack.append(layer)
+
+    logger.info("Extracting surface from 3D grid... DONE")
+
+    return layerstack, "tops", "stratigraphic"

xtgeo/surface/_zmap_parser.py

@@ -0,0 +1,138 @@
+"""ZMAP plus parsing.
+
+cf https://saurabhkukade.com/posts/2020/07/understanding-zmap-file-format/
+
+Note also from example here:
+https://raw.githubusercontent.com/abduhbm/zmapio/main/examples/NSLCU.dat
+that header lines may end with trailing comma!
+"""
+
+import dataclasses
+import inspect
+from functools import wraps
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+
+@dataclasses.dataclass
+class ZMAPSurface:
+    nrow: int
+    ncol: int
+    xmin: float
+    xmax: float
+    ymin: float
+    ymax: float
+    node_width: int
+    precision: int
+    start_column: int
+    nan_value: float
+    nr_nodes_per_line: int
+    values: Optional[np.array] = None
+
+    def __post_init__(self):
+        for field in dataclasses.fields(self):
+            value = getattr(self, field.name)
+            if field.type in (int, float) and not isinstance(value, field.type):
+                setattr(self, field.name, field.type(value))
+
+
+def takes_stream(name, mode):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            kwargs = inspect.getcallargs(func, *args, **kwargs)
+            if name in kwargs and isinstance(kwargs[name], (str, Path)):
+                with open(kwargs[name], mode) as f:
+                    kwargs[name] = f
+                    return func(**kwargs)
+            else:
+                return func(**kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def parse_header(zmap_data):
+    keys = {}
+    line_nr = 0
+    for line in zmap_data:
+        if is_comment(line):
+            continue
+        try:
+            line = [entry.strip() for entry in line.split(",")]
+            if not line[-1]:
+                line.pop()  # deal with input lines ending with comma ','
+            if line_nr == 0:
+                _, identifier, keys["nr_nodes_per_line"] = line
+                if identifier != "GRID":
+                    raise ZMAPFormatException(
+                        f"Expected GRID as second entry in line, "
+                        f"got: {identifier} in line: {line}"
+                    )
+            elif line_nr == 1:
+                (
+                    keys["node_width"],
+                    dft_nan_value,
+                    user_nan_value,
+                    keys["precision"],
+                    keys["start_column"],
+                ) = line
+                keys["nan_value"] = dft_nan_value if dft_nan_value else user_nan_value
+            elif line_nr == 2:
+                (
+                    keys["nrow"],
+                    keys["ncol"],
+                    keys["xmin"],
+                    keys["xmax"],
+                    keys["ymin"],
+                    keys["ymax"],
+                ) = line
+            elif line_nr == 3:
+                _, _, _ = line
+            elif line_nr >= 4 and line[0] != "@":
+                raise ZMAPFormatException(
+                    f"Did not reach the values section, expected @, found: {line}"
+                )
+            else:
+                return keys
+        except ValueError as err:
+            raise ZMAPFormatException(f"Failed to unpack line: {line}") from err
+        line_nr += 1
+    raise ZMAPFormatException("End reached without complete header")
+
+
+def is_comment(line):
+    return line.startswith(("!", "+"))
+
+
+def parse_values(zmap_data, nan_value):
+    """Parse actual values in zmap plus ascii files.
+
+    Note that header's node_width and nr_nodes_per_line in ZMAP header are not applied,
+    meaning that values import here is more tolerant than original zmap spec.
+    """
+    values = []
+    for line in zmap_data:
+        if not is_comment(line):
+            values += line.split()
+
+    return np.ma.masked_equal(
+        np.array(values, dtype=np.float32),
+        nan_value,
+    )
+
+
+@takes_stream("zmap_file", "r")
+def parse_zmap(zmap_file, load_values=True):
+    header = parse_header(zmap_file)
+    zmap_data = ZMAPSurface(**header)
+    if load_values:
+        zmap_data.values = parse_values(zmap_file, zmap_data.nan_value)
+    return zmap_data
+
+
+class ZMAPFormatException(Exception):
+    pass