xtgeo 4.8.0__cp313-cp313-win_amd64.whl

xtgeo/grid3d/_grid_roxapi.py

@@ -0,0 +1,292 @@
+"""Roxar API functions for XTGeo Grid Geometry."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import TYPE_CHECKING, Any, Literal
+
+import numpy as np
+
+import xtgeo._internal as _internal
+from xtgeo.common import XTGeoDialog, null_logger
+from xtgeo.roxutils._roxar_loader import roxar, roxar_grids
+from xtgeo.roxutils.roxutils import RoxUtils
+
+xtg = XTGeoDialog()
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d.grid import Grid
+    # from xtgeo.roxutils._roxar_loader import RoxarGrid3DType
+
+    if roxar is not None:
+        from roxar import grids as RoxarGridType
+        from roxar.grids import Grid3D as RoxarGrid3DType
+
+
+# self is Grid() instance
+
+
+# ======================================================================================
+# Load/import
+# ======================================================================================
+
+
+def load_grid_from_rms(
+    projectname: str, gname: str, realisation: int, info: bool
+) -> dict[str, Any]:
+    """Load a Grid via ROXAR API spec and convert to XTGeo internal storage.
+
+    Returns:
+        dictionary of parameters to be used in the Grid constructor function.
+
+    """
+
+    rox = RoxUtils(projectname, readonly=True)
+    return _load_grid_from_rms_viaroxapi(rox, gname, realisation, info)
+
+
+def _display_roxapi_grid_info(roxgrid: RoxarGrid3DType) -> None:
+    """Push info to screen (mostly for debugging), experimental."""
+
+    indexer = roxgrid.grid_indexer
+    ncol, nrow, _ = indexer.dimensions
+
+    xtg.say("ROXAPI with support for CornerPointGridGeometry")
+    geom = roxgrid.get_geometry()
+    defined_cells = geom.get_defined_cells()
+    xtg.say(f"Defined cells \n{defined_cells}")
+
+    xtg.say(f"IJK handedness: {geom.ijk_handedness}")
+    for ipi in range(ncol + 1):
+        for jpi in range(nrow + 1):
+            tpi, bpi, zco = geom.get_pillar_data(ipi, jpi)
+            xtg.say(f"For pillar {ipi}, {jpi}\n")
+            xtg.say(f"Tops\n{tpi}")
+            xtg.say(f"Bots\n{bpi}")
+            xtg.say(f"Depths\n{zco}")
+
+
+def _load_grid_from_rms_viaroxapi(
+    rox: RoxUtils, gname: str, realisation: int, info: bool
+) -> dict[str, Any]:
+    """Import a Grid via ROXAR API spec."""
+    proj = rox.project
+
+    logger.info("Loading grid with realisation %s...", realisation)
+    try:
+        if gname not in proj.grid_models:
+            raise KeyError(f"No such gridmodel: {gname}")
+
+        logger.info("Get roxgrid...")
+        roxgrid = proj.grid_models[gname].get_grid(realisation=realisation)
+
+        if roxgrid.has_dual_index_system:
+            xtg.warnuser(
+                f"The roxar grid {gname} has dual index system.\n"
+                "XTGeo does not implement extraction of simbox grid\n"
+                "and only considers physical index."
+            )
+
+        if info:
+            _display_roxapi_grid_info(roxgrid)
+
+        result = _convert_to_xtgeo_grid(roxgrid, gname)
+
+    except KeyError as keyerror:
+        raise RuntimeError(keyerror)
+
+    if rox._roxexternal:
+        rox.safe_close()
+
+    return result
+
+
+def _convert_to_xtgeo_grid(roxgrid: RoxarGrid3DType, gname: str) -> dict[str, Any]:
+    """Convert from roxar CornerPointGeometry to xtgeo, version 2 using _xtgformat=2."""
+    indexer = roxgrid.grid_indexer
+
+    ncol, nrow, nlay = indexer.dimensions
+
+    # update other attributes
+    result: dict[str, Any] = {}
+
+    nncol = ncol + 1
+    nnrow = nrow + 1
+    nnlay = nlay + 1
+
+    result["name"] = gname
+
+    geom = roxgrid.get_geometry()
+
+    coordsv = np.zeros((nncol, nnrow, 6), dtype=np.float64)
+    zcornsv = np.zeros((nncol, nnrow, nnlay, 4), dtype=np.float32)
+    actnumsv = np.zeros((ncol, nrow, nlay), dtype=np.int32)
+    for icol in range(nncol):
+        for jrow in range(nnrow):
+            topc, basc, zcorn = geom.get_pillar_data(icol, jrow)
+            coordsv[icol, jrow, 0:3] = topc
+            coordsv[icol, jrow, 3:6] = basc
+            zcorn = np.ma.filled(zcorn, fill_value=np.nan)
+            zcornsv[icol, jrow, :, :] = zcorn.T
+
+    median_zcornsv = np.nanmedian(zcornsv)
+    # replace nan with median of the zorner values
+    zcornsv[np.isnan(zcornsv)] = median_zcornsv
+
+    _internal.grid3d.process_edges_rmsapi(zcornsv)
+
+    result["coordsv"] = coordsv
+    result["zcornsv"] = zcornsv
+
+    actnumsv[geom.get_defined_cells()] = 1
+    result["actnumsv"] = actnumsv
+
+    # subgrids
+    if len(indexer.zonation) > 1:
+        logger.debug("Zonation length (N subzones) is %s", len(indexer.zonation))
+        subz = {}
+        for inum, zrange in indexer.zonation.items():
+            logger.debug("inum: %s, zrange: %s", inum, zrange)
+            zname = roxgrid.zone_names[inum]
+            logger.debug("zname is: %s", zname)
+            zra = [nn + 1 for ira in zrange for nn in ira]  # nested lists
+            subz[zname] = zra
+
+        result["subgrids"] = subz
+
+    result["roxgrid"] = roxgrid
+    result["roxindexer"] = indexer
+
+    return result
+
+
+# ======================================================================================
+# Save/export
+# ======================================================================================
+
+
+def save_grid_to_rms(
+    self: Grid,
+    projectname: str,
+    gname: str,
+    realisation: int,
+    info: bool = False,
+    method: str | Literal["cpg", "roff"] = "cpg",
+) -> None:
+    """Save (i.e. store in RMS) via RMSAPI (former ROXAPI) spec.
+
+    Using method 'cpg' means that the CPG method is applied (from ROXAPI 1.3).
+    This is possible from version ROXAPI ver 1.3, where the CornerPointGeometry
+    class is defined.
+
+    An alternative is to use simple roff import (via some /tmp area),
+    can be used from version 1.2. The "roff" method is also better if the user
+    want to activate undefined cells as a part of the work flow.
+
+    """
+    rox = RoxUtils(projectname, readonly=False)
+
+    if method == "cpg":
+        self._xtgformat2()
+        _save_grid_to_rms_cornerpoint(self, rox, gname, realisation, info)
+
+    else:
+        _save_grid_to_rms_viaroff(self, rox, gname, realisation)
+
+    if rox._roxexternal:
+        rox.project.save()
+
+    rox.safe_close()
+
+
+def _save_grid_to_rms_cornerpoint(
+    self: Grid, rox: RoxUtils, gname: str, realisation: int, info: bool
+) -> None:
+    """Convert xtgeo geometry to pillar spec in ROXAPI and store _xtgformat=2."""
+
+    grid_model = rox.project.grid_models.create(gname)
+    grid_model.set_empty(realisation)
+    grid = grid_model.get_grid(realisation)
+
+    roxar_grids_: RoxarGridType = roxar_grids  # for mypy
+    geom = roxar_grids_.CornerPointGridGeometry.create(self.dimensions)
+
+    grid_cpp = _internal.grid3d.Grid(self)
+    tpi, bpi, zco, zma = grid_cpp.convert_xtgeo_to_rmsapi()
+    zco = np.ma.array(zco, mask=zma)
+
+    # NOTE (KEEP), it is a bit unclear if mask is needed. A possible simpilification is
+    # zco = self._zcornsv.astype(np.float64)
+    # zco = np.moveaxis(zco, 2, 3)
+    # tpi = self._coordsv[:, :, 0:3]
+    # bpi = self._coordsv[:, :, 3:6]
+    # This would be 10-20% faster, but the mask is kept for now.
+
+    for ipi in range(self.ncol + 1):
+        for jpi in range(self.nrow + 1):
+            geom.set_pillar_data(
+                ipi,
+                jpi,
+                top_point=tpi[ipi, jpi],
+                bottom_point=bpi[ipi, jpi],
+                depth_values=zco[ipi, jpi],
+            )
+
+    geom.set_defined_cells(self._actnumsv.astype(bool))
+    grid.set_geometry(geom)
+    _set_subgrids(self, rox, grid)
+
+
+def _set_subgrids(self: Grid, rox: RoxUtils, grid: RoxarGrid3DType) -> None:
+    """Export the subgrid index (zones) to Roxar API.
+
+    From roxar API:
+        set_zonation(zone_dict)
+
+            zone_dict A dictionary with start-layer (zero based) and name for each zone.
+
+    """
+
+    if not self.subgrids:
+        return
+
+    if rox.version_required("1.6"):
+        subs = self.subgrids
+        roxar_subs = {}
+        for name, zrange in subs.items():
+            roxar_subs[int(zrange[0] - 1)] = name
+
+        grid.set_zonation(roxar_subs)
+
+    else:
+        xtg.warnuser(
+            "Implementation of subgrids is lacking in Roxar API for this "
+            "RMS version. Will continue to store in RMS but without subgrid index."
+        )
+
+
+def _save_grid_to_rms_viaroff(
+    self: Grid, rox: RoxUtils, gname: str, realisation: int
+) -> None:
+    """Save xtgeo geometry to internal RMS via i/o ROFF tricks."""
+    logger.info("Realisation is %s", realisation)
+
+    # make a temporary folder and work within the with.. block
+    with tempfile.TemporaryDirectory() as tmpdir:
+        logger.info("Made a tmp folder: %s", tmpdir)
+
+        fname = os.path.join(tmpdir, gname)
+        self.to_file(fname)
+
+        grd = rox.project.grid_models
+
+        try:
+            del grd[gname]
+            logger.info("Overwriting existing grid in RMS")
+        except KeyError:
+            logger.info("Grid in RMS is new")
+
+        grd.load(fname)

xtgeo/grid3d/_grid_wellzone.py

@@ -0,0 +1,165 @@
+"""Private module for grid vs well zonelog checks."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+
+from xtgeo.common import XTGeoDialog, null_logger
+from xtgeo.grid3d.grid_property import GridProperty
+from xtgeo.well import Well
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+
+def report_zone_mismatch(
+    self: Grid,
+    well: Well | None = None,
+    zonelogname: str = "ZONELOG",
+    zoneprop: GridProperty | None = None,
+    zonelogrange: tuple[int, int] = (0, 9999),
+    zonelogshift: int = 0,
+    depthrange: tuple[int | float, int | float] | None = None,
+    perflogname: str | None = None,
+    perflogrange: tuple[int | float, int | float] = (1, 9999),
+    filterlogname: str | None = None,
+    filterlogrange: tuple[int | float, int | float] = (1e-32, 9999.0),
+    resultformat: Literal[1, 2] = 1,
+) -> dict[str, float | int | Well] | tuple[float, int, int] | None:  # pylint: disable=too-many-locals, too-many-branches, too-many-statements
+    """Reports well to zone mismatch; this works together with a Well object.
+
+    The idea is to sample the current zone property for the well in the grid as fast as
+    possible.
+
+    Then the sampled zonelog is compared with the actual zonelog, and the difference
+    is reported.
+
+    One can apply a perforation log as a mask, meaning that we filter zonelog
+    match in intervals with a perforation log only if requested.
+
+    This method was completely redesigned in version 2.8
+    """
+    self._xtgformat1()
+
+    if not isinstance(well, Well):
+        raise ValueError("Input well is not a Well() instance")
+
+    if zoneprop is None or not isinstance(zoneprop, GridProperty):
+        raise ValueError("Input zoneprop is missing or not a GridProperty() instance")
+
+    if zonelogname not in well.get_dataframe(copy=False).columns:
+        logger.warning("Zonelog %s is missing for well %s", zonelogname, well.name)
+        return None
+
+    if perflogname == "None" or perflogname is None:  # "None" for backwards compat
+        logger.info("No perforation log as filter")
+        perflogname = None
+
+    # get the IJK along the well as logs; use a copy of the well instance
+    wll = well.copy()
+    wll_df = wll.get_dataframe()
+    wll_df[zonelogname] += zonelogshift
+
+    if depthrange:
+        d1, d2 = depthrange
+        wll_df = wll_df[(d1 < wll_df.Z_TVDSS) & (d2 > wll_df.Z_TVDSS)]
+    wll.set_dataframe(wll_df)
+
+    wll.get_gridproperties(zoneprop, self)
+    zonename = zoneprop.name if zoneprop.name is not None else "Zone"
+    zmodel = zonename + "_model"
+
+    # from here, work with the dataframe only
+    df = wll.get_dataframe()
+
+    # zonelogrange
+    z1, z2 = zonelogrange
+    zmin = zmax = 0
+    try:
+        zmin = int(df[zonelogname].min())
+    except ValueError as verr:
+        if "cannot convert" in str(verr):
+            msg = f"TVD range {depthrange} is possibly to narrow? ({str(verr)})"
+            raise ValueError(msg)
+    try:
+        zmax = int(df[zonelogname].max())
+    except ValueError as verr:
+        if "cannot convert" in str(verr):
+            msg = f"TVD range {depthrange} is possibly to narrow? ({str(verr)})"
+            raise ValueError(msg)
+
+    skiprange = list(range(zmin, z1)) + list(range(z2 + 1, zmax + 1))
+
+    for zname in (zonelogname, zmodel):
+        if skiprange:  # needed check; du to a bug in pandas version 0.21 .. 0.23
+            df[zname] = df[zname].replace(skiprange, -888)
+        df[zname] = df[zname].fillna(-999)
+        if perflogname:
+            if perflogname in df.columns:
+                df[perflogname] = df[perflogname].replace(np.nan, -1)
+                pfr1, pfr2 = perflogrange
+                df[zname] = np.where(df[perflogname] < pfr1, -899, df[zname])
+                df[zname] = np.where(df[perflogname] > pfr2, -899, df[zname])
+            else:
+                return None
+        if filterlogname:
+            if filterlogname in df.columns:
+                df[filterlogname] = df[filterlogname].replace(np.nan, -1)
+                ffr1, ffr2 = filterlogrange
+                df[zname] = np.where(df[filterlogname] < ffr1, -919, df[zname])
+                df[zname] = np.where(df[filterlogname] > ffr2, -919, df[zname])
+            else:
+                return None
+
+    # now there are various variotions on how to count mismatch:
+    # dfuse 1: count matches when zonelogname is valid (exclude -888)
+    # dfuse 2: count matches when zonelogname OR zmodel are valid (exclude < -888
+    # or -999)
+    # The first one is the original approach
+
+    dfuse1 = df.copy(deep=True)
+    dfuse1 = dfuse1.loc[dfuse1[zonelogname] > -888]
+
+    dfuse1["zmatch1"] = np.where(dfuse1[zmodel] == dfuse1[zonelogname], 1, 0)
+    mcount1 = dfuse1["zmatch1"].sum()
+    tcount1 = dfuse1["zmatch1"].count()
+    if not np.isnan(mcount1):
+        mcount1 = int(mcount1)
+    if not np.isnan(tcount1):
+        tcount1 = int(tcount1)
+
+    res1 = dfuse1["zmatch1"].mean() * 100
+
+    if resultformat == 1:
+        return (res1, mcount1, tcount1)
+
+    dfuse2 = df.copy(deep=True)
+    dfuse2 = dfuse2.loc[(df[zmodel] > -888) | (df[zonelogname] > -888)]
+    dfuse2["zmatch2"] = np.where(dfuse2[zmodel] == dfuse2[zonelogname], 1, 0)
+    mcount2 = dfuse2["zmatch2"].sum()
+    tcount2 = dfuse2["zmatch2"].count()
+    if not np.isnan(mcount2):
+        mcount2 = int(mcount2)
+    if not np.isnan(tcount2):
+        tcount2 = int(tcount2)
+
+    res2 = dfuse2["zmatch2"].mean() * 100
+
+    # update Well() copy (segment only)
+    wll.set_dataframe(dfuse2)
+
+    return {
+        "MATCH1": res1,
+        "MCOUNT1": mcount1,
+        "TCOUNT1": tcount1,
+        "MATCH2": res2,
+        "MCOUNT2": mcount2,
+        "TCOUNT2": tcount2,
+        "WELLINTV": wll,
+    }

xtgeo/grid3d/_gridprop_export.py

@@ -0,0 +1,178 @@
+"""GridProperty export functions."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import struct
+from contextlib import ExitStack
+from typing import IO, TYPE_CHECKING, Any, Literal
+
+import numpy as np
+import resfo
+import roffio
+
+from xtgeo.common.exceptions import InvalidFileFormatError
+from xtgeo.common.log import null_logger
+from xtgeo.io._file import FileFormat, FileWrapper
+
+from ._roff_parameter import RoffParameter
+
+if TYPE_CHECKING:
+    from xtgeo.common.types import FileLike
+
+    from .grid_property import GridProperty
+
+logger = null_logger(__name__)
+
+
+def to_file(
+    gridprop: GridProperty,
+    pfile: FileLike,
+    fformat: Literal["roff", "roffasc", "grdecl", "bgrdecl", "xtgcpprop"] = "roff",
+    name: str | None = None,
+    append: bool = False,
+    dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
+    fmt: str | None = None,
+) -> None:
+    """Export the grid property to file."""
+    logger.debug("Export property to file %s as %s", pfile, fformat)
+
+    binary = fformat in (
+        FileFormat.ROFF_BINARY.value + FileFormat.BGRDECL.value + ["xtgcpprop"]
+    )
+
+    if not name:
+        name = gridprop.name or ""
+
+    xtg_file = FileWrapper(pfile, mode="rb")
+    xtg_file.check_folder(raiseerror=OSError)
+
+    if fformat in FileFormat.ROFF_BINARY.value + FileFormat.ROFF_ASCII.value:
+        _export_roff(gridprop, xtg_file.name, name, binary, append=append)
+    elif fformat in FileFormat.GRDECL.value + FileFormat.BGRDECL.value:
+        _export_grdecl(
+            gridprop,
+            xtg_file.name,
+            name,
+            dtype=dtype or np.int32 if gridprop.isdiscrete else np.float32,
+            append=append,
+            binary=binary,
+            fmt=fmt,
+        )
+    elif fformat == "xtgcpprop":
+        _export_xtgcpprop(gridprop, xtg_file.name)
+    else:
+        extensions = FileFormat.extensions_string(
+            [
+                FileFormat.ROFF_BINARY,
+                FileFormat.ROFF_ASCII,
+                FileFormat.GRDECL,
+                FileFormat.BGRDECL,
+            ]
+        )
+        raise InvalidFileFormatError(
+            f"File format {fformat} is invalid for type GridProperty. "
+            f"Supported formats are {extensions}."
+        )
+
+
+def _export_roff(
+    gridprop: GridProperty,
+    pfile: str | io.BytesIO | io.StringIO,
+    name: str,
+    binary: bool,
+    append: bool = False,
+) -> None:
+    if append:
+        logger.warning(
+            "Append is not implemented for roff format, defaulting to write."
+        )
+    roff = RoffParameter.from_xtgeo_grid_property(gridprop)
+    roff.name = name
+    roff.to_file(pfile, roffio.Format.BINARY if binary else roffio.Format.ASCII)
+
+
+def _export_grdecl(
+    gridprop: GridProperty,
+    pfile: str | io.BytesIO | io.StringIO,
+    name: str,
+    dtype: type[np.float32] | type[np.float64] | type[np.int32],
+    append: bool = False,
+    binary: bool = False,
+    fmt: str | None = None,
+) -> None:
+    """Export ascii or binary GRDECL"""
+    vals = gridprop.values.ravel(order="F")
+    if np.ma.isMaskedArray(vals):
+        undef_export = 1 if gridprop.isdiscrete or "int" in str(dtype) else 0.0
+        vals = np.ma.filled(vals, fill_value=undef_export)
+
+    mode = "a" if append else "w"
+    if binary:
+        mode += "b"
+
+    with ExitStack() as stack:
+        fout = (
+            stack.enter_context(open(pfile, mode)) if isinstance(pfile, str) else pfile
+        )
+
+        if append:
+            fout.seek(os.SEEK_END)
+
+        if binary:
+            resfo.write(
+                fout,
+                [(name.ljust(8), vals.astype(dtype))],
+                fileformat=resfo.Format.UNFORMATTED,
+            )
+        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(" /\n")
+
+
+def _export_xtgcpprop(
+    gridprop: GridProperty, pfile: str | io.BytesIO | io.StringIO
+) -> None:
+    """Export to experimental xtgcpproperty format, python version."""
+    logger.debug("Export as xtgcpprop...")
+    gridprop._metadata.required = gridprop
+
+    magic = 1352 if gridprop.isdiscrete else 1351
+    prevalues = (1, magic, 4, gridprop.ncol, gridprop.nrow, gridprop.nlay)
+    mystruct = struct.Struct("= i i i q q q")
+    pre = mystruct.pack(*prevalues)
+
+    meta = gridprop.metadata.get_metadata()
+
+    # Convert StringIO to BytesIO as this is a binary format
+    with ExitStack() as stack:
+        if isinstance(pfile, io.StringIO):
+            data = pfile.getvalue().encode("utf-8")
+            fout: IO[Any] = io.BytesIO(data)
+        elif isinstance(pfile, io.BytesIO):
+            fout = pfile
+        else:
+            fout = stack.enter_context(open(pfile, "wb"))
+        fout.write(pre)
+        gridprop.get_npvalues1d(fill_value=gridprop.undef).astype(np.float32).tofile(
+            fout
+        )
+        fout.write("\nXTGMETA.v01\n".encode())
+        fout.write(json.dumps(meta).encode())
+
+    logger.debug("Export as xtgcpprop... done")