xtgeo 4.14.1__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._set_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 = self._get_grid_cpp()
+    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_translate_coords.py

@@ -0,0 +1,154 @@
+"""Private module for translating coordiantes plus flipping and rotation."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+def _rotate_grid3d(
+    new_grd: Grid, add_rotation: float, rotation_xy: tuple[float, float] | None = None
+) -> None:
+    """Rotate the grid around the cell 1,1,1 corner, or some other coordinate."""
+
+    # Convert angle to radians
+    angle_rad = math.radians(add_rotation)
+
+    # Create rotation matrix coefficients
+    cos_theta = math.cos(angle_rad)
+    sin_theta = math.sin(angle_rad)
+
+    # extract
+    coord_array = new_grd._coordsv.copy()
+    rotated_coords = coord_array.copy()
+
+    if rotation_xy is None:
+        x0, y0, _ = new_grd._coordsv[0, 0, :3]
+    else:
+        x0, y0 = rotation_xy
+
+    x_coords = coord_array[:, :, [0, 3]].copy()  # x1 and x2
+    y_coords = coord_array[:, :, [1, 4]].copy()  # y1 and y2
+
+    # Translate to origin
+    x_translated = x_coords - x0
+    y_translated = y_coords - y0
+
+    # Rotate using rotation matrix
+    x_rotated = x_translated * cos_theta - y_translated * sin_theta
+    y_rotated = x_translated * sin_theta + y_translated * cos_theta
+
+    # Translate back and assign
+    rotated_coords[:, :, [0, 3]] = x_rotated + x0
+    rotated_coords[:, :, [1, 4]] = y_rotated + y0
+
+    # Z coordinates remain unchanged (indices 2 and 5)
+    new_grd._coordsv = rotated_coords.copy()
+
+
+def _flip_vertically(grid: Grid) -> None:
+    """Flip the grid vertically."""
+
+    # find average depth of corners
+    avg_z = grid._zcornsv.mean()
+
+    grid._zcornsv = grid._zcornsv[:, :, ::-1, :]
+    grid._zcornsv *= -1
+
+    # find the new average and compute the difference for shifting
+    new_avg_z = grid._zcornsv.mean()
+    diff = avg_z - new_avg_z
+    grid._zcornsv += diff
+
+    grid._actnumsv = np.flip(grid._actnumsv, axis=2).copy()
+
+    # Handle properties if they exist
+    if grid._props and grid._props.props:
+        for prop in grid._props.props:
+            prop.values = np.flip(prop.values, axis=2).copy()
+
+    # When we flip the grid, the subgrid info must also be flipped
+    subgrids = grid.get_subgrids()
+    if subgrids:
+        reverted = dict(reversed(subgrids.items()))
+        grid.set_subgrids(reverted)
+
+    if grid._ijk_handedness == "left":
+        grid._ijk_handedness = "right"
+    else:
+        grid._ijk_handedness = "left"
+
+
+def _translate_geometry(grid: Grid, translate: tuple[float, float, float]) -> None:
+    grid._coordsv[:, :, 0] += translate[0]
+    grid._coordsv[:, :, 1] += translate[1]
+    grid._coordsv[:, :, 2] += translate[2]
+    grid._coordsv[:, :, 3] += translate[0]
+    grid._coordsv[:, :, 4] += translate[1]
+    grid._coordsv[:, :, 5] += translate[2]
+
+    grid._zcornsv += translate[2]
+
+
+def _transfer_to_target(grid: Grid, target: tuple[float, float, float]) -> None:
+    # get the coordinates for the active cells
+    x, y, z = grid.get_xyz(asmasked=True)
+
+    # set the grid center to the desired target coordinates
+    shift_x = target[0] - x.values.mean()
+    shift_y = target[1] - y.values.mean()
+    shift_z = target[2] - z.values.mean()
+
+    _translate_geometry(grid, (shift_x, shift_y, shift_z))
+
+
+def translate_coordinates(
+    self: Grid,
+    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    flip: tuple[int, int, int] = (1, 1, 1),
+    add_rotation: float = 0.0,
+    rotation_point: tuple[float, float] | None = None,
+    target_coordinates: tuple[float, float, float] | None = None,
+) -> None:
+    """Rotate, flip grid and translate grid coordinates.
+
+    This should be done in a sequence like this
+    1) Add rotation (with value ``add_rotation``) to rotate the grid counter-clockwise
+    2) Flip the grid
+    3a) translate the grid by adding (x, y, z), OR
+    3b) set a target location the grid centre.
+
+    """
+    self._set_xtgformat2()
+
+    if abs(add_rotation) > 1e-10:  # Skip rotation if angle is essentially zero
+        _rotate_grid3d(self, add_rotation, rotation_xy=rotation_point)
+
+    if flip[2] == -1:
+        _flip_vertically(self)
+
+    if flip[0] == -1:
+        self.reverse_column_axis()
+
+    if flip[1] == -1:
+        self.reverse_row_axis()
+
+    use_translate = False
+    if not all(abs(x) < 1e-10 for x in translate):
+        _translate_geometry(self, translate)
+        use_translate = True
+
+    if target_coordinates and use_translate:
+        raise ValueError(
+            "Using both key 'translate' and key 'target_coordinates' is not allowed. "
+            "Use either."
+        )
+
+    if target_coordinates:
+        # transfer the grid's geometrical centre to a given location
+        _transfer_to_target(self, target_coordinates)

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._set_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,
+    }