xtgeo 4.8.0__cp313-cp313-win_amd64.whl

xtgeo/grid3d/_gridprop_op1.py

@@ -0,0 +1,174 @@
+"""Various grid property operations"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Literal, Optional, Tuple, Union
+
+import numpy as np
+
+import xtgeo
+from xtgeo import _cxtgeo
+from xtgeo.common import XTGeoDialog, null_logger
+from xtgeo.grid3d import _gridprop_lowlevel as gl
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid, GridProperty
+    from xtgeo.xyz import Polygons
+
+_CoordOrValue = Union[float, int]
+_XYCoordinate = Tuple[_CoordOrValue, _CoordOrValue]
+_XYCoordList = List[List[List[_XYCoordinate]]]
+_ValueList = List[List[_CoordOrValue]]
+XYValueLists = Tuple[_XYCoordList, _ValueList]
+
+
+def get_xy_value_lists(
+    self: GridProperty,
+    grid: Optional[Grid | GridProperty] = None,
+    mask: Optional[bool] = None,
+) -> XYValueLists:
+    """Get values for webportal format
+
+    Two cells:
+    [[[(x1,y1), (x2,y2), (x3,y3), (x4,y4)],
+    [(x5,y5), (x6,y6), (x7,y7), (x8,y8)]]]
+
+    If mask is True then inactive cells are ommited from the lists,
+    else the active cells corners will be present while the property
+    will have a -999 value.
+
+    """
+    if grid is None:
+        raise RuntimeError("Missing grid object")
+
+    if not isinstance(grid, xtgeo.grid3d.Grid):
+        raise RuntimeError("The input grid is not a XTGeo Grid instance")
+
+    if not isinstance(self, xtgeo.grid3d.GridProperty):
+        raise RuntimeError("The property is not a XTGeo GridProperty instance")
+
+    clist = grid.get_xyz_corners()
+    actnum = grid.get_actnum()
+
+    # set value 0 if actnum is 0 to facilitate later operations
+    if mask:
+        for cli in clist:
+            cli.values[actnum.values == 0] = 0
+
+    # now some numpy operations (coffee?, any?)
+    xy0 = np.column_stack((clist[0].values1d, clist[1].values1d))
+    xy1 = np.column_stack((clist[3].values1d, clist[4].values1d))
+    xy2 = np.column_stack((clist[6].values1d, clist[7].values1d))
+    xy3 = np.column_stack((clist[9].values1d, clist[10].values1d))
+
+    xyc = np.column_stack((xy0, xy1, xy2, xy3))
+    xyc = xyc.reshape(grid.nlay, grid.ncol * grid.nrow, 4, 2)
+
+    coordlist = xyc.tolist()
+
+    # remove cells that are undefined ("marked" as coordinate [0, 0] if mask)
+    coordlist = [
+        [[tuple(xy) for xy in cell if xy[0] > 0] for cell in lay] for lay in coordlist
+    ]
+
+    coordlist = [[cell for cell in lay if len(cell) > 1] for lay in coordlist]
+
+    pval = self.values1d.reshape((grid.nlay, grid.ncol * grid.nrow))
+    valuelist = pval.tolist(fill_value=-999.0)
+    if mask:
+        valuelist = [[val for val in lay if val != -999.0] for lay in valuelist]
+
+    return coordlist, valuelist
+
+
+def operation_polygons(
+    self: GridProperty,
+    poly: Polygons,
+    value: float | int,
+    opname: Literal["add", "sub", "mul", "div", "set"] = "add",
+    inside: bool = True,
+) -> None:
+    """A generic function for doing operations restricted to inside
+    or outside polygon(s).
+
+    """
+    grid = self.geometry
+    grid._xtgformat1()
+
+    if not isinstance(poly, xtgeo.xyz.Polygons):
+        raise ValueError("The poly input is not a Polygons instance")
+
+    # make a copy of the array which is used a "filter" or "proxy"
+    # value will be 1 inside polygons, 0 outside. Undef cells are kept as is
+    dtype = self.dtype
+
+    proxy = self.copy()
+    proxy.discrete_to_continuous()
+
+    proxy.values *= 0.0
+    cvals = gl.update_carray(proxy)
+
+    idgroups = poly.get_dataframe(copy=False).groupby(poly.pname)
+
+    for id_, grp in idgroups:
+        xcor = grp[poly.xname].values
+        ycor = grp[poly.yname].values
+
+        ier = _cxtgeo.grd3d_setval_poly(
+            xcor,
+            ycor,
+            self.ncol,
+            self.nrow,
+            self.nlay,
+            grid._coordsv,
+            grid._zcornsv,
+            grid._actnumsv,
+            cvals,
+            1,
+        )
+        if ier == -9:
+            logger.warning(f"Polygon no {id_ + 1} is not closed")
+
+    gl.update_values_from_carray(proxy, cvals, np.float64, delete=True)
+
+    proxyv = proxy.values.astype(np.int8)
+
+    proxytarget = 1
+    if not inside:
+        proxytarget = 0
+
+    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 np.isclose(value, 0.0):
+            xtg.warn(
+                "Dividing a surface with value or surface with zero "
+                "elements; may get unexpected results, try to "
+                "achieve zero values as result!"
+            )
+        with np.errstate(divide="ignore", invalid="ignore"):
+            this = np.ma.filled(self.values, fill_value=1.0)
+            that = np.ma.filled(value, fill_value=1.0)
+            mask = np.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 = np.ma.array(tmp, mask=mask)
+
+    elif opname == "set":
+        tmp = self.values.copy() * 0 + value
+
+    # convert tmp back to correct dtype
+    tmp = tmp.astype(dtype)
+
+    self.values[proxyv == proxytarget] = tmp[proxyv == proxytarget]
+    del tmp

xtgeo/grid3d/_gridprop_roxapi.py

@@ -0,0 +1,239 @@
+# coding: utf-8
+"""Roxar API functions for XTGeo Grid Property."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+import numpy as np
+from numpy import ma
+
+from xtgeo.common import null_logger
+from xtgeo.common.constants import UNDEF, UNDEF_INT, UNDEF_INT_LIMIT, UNDEF_LIMIT
+from xtgeo.roxutils import RoxUtils
+from xtgeo.roxutils._roxar_loader import roxar
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d.grid_property import GridProperty
+
+    if roxar is not None:
+        from roxar import Project as RoxarProjectType
+        from roxar.grids import Grid3D as RoxarGrid3DType
+
+logger = null_logger(__name__)
+
+VALID_ROXAR_DTYPES = [np.uint8, np.uint16, np.float32]
+
+
+def import_prop_roxapi(
+    project: RoxarProjectType,
+    gname: str,
+    pname: str,
+    realisation: int,
+    faciescodes: bool,
+) -> dict[str, Any]:
+    """Import a Property via ROXAR API spec."""
+    logger.info("Opening RMS project ...")
+
+    rox = RoxUtils(project, readonly=True)
+
+    result = _get_gridprop_data(rox, gname, pname, realisation, faciescodes)
+
+    rox.safe_close()
+    return result
+
+
+def _get_gridprop_data(
+    rox: RoxUtils, gname: str, pname: str, realisation: int, faciescodes: bool
+) -> dict[str, Any]:
+    # inside a RMS project
+
+    if gname not in rox.project.grid_models:
+        raise ValueError(f"No gridmodel with name {gname}")
+    if pname not in rox.project.grid_models[gname].properties:
+        raise ValueError(f"No property in {gname} with name {pname}")
+
+    try:
+        return _convert_to_xtgeo_prop(rox, gname, pname, realisation, faciescodes)
+    except KeyError as keyerror:
+        raise RuntimeError(keyerror) from keyerror
+
+
+def _convert_to_xtgeo_prop(
+    rox: RoxUtils, gname: str, pname: str, realisation: int, faciescodes: bool
+) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    roxgrid = rox.project.grid_models[gname]
+    roxprop = roxgrid.properties[pname]
+
+    discrete = str(roxprop.type) in ("discrete", "body_facies")
+    result["discrete"] = discrete
+
+    result["roxorigin"] = True
+    indexer = roxgrid.get_grid(realisation=realisation).grid_indexer
+    result["ncol"], result["nrow"], result["nlay"] = indexer.dimensions
+
+    logger.info(indexer.ijk_handedness)
+
+    pvalues = roxprop.get_values(realisation=realisation)
+
+    if str(roxprop.type) == "body_facies" and faciescodes:
+        fmap = roxprop.get_facies_map(realisation=realisation)
+        pvalues = fmap[pvalues]  # numpy magics
+
+    result["roxar_dtype"] = pvalues.dtype
+
+    mybuffer: np.ndarray = np.ndarray(
+        indexer.dimensions, dtype=np.int32 if discrete else np.float64
+    )
+    mybuffer.fill(UNDEF_INT if discrete else UNDEF)
+
+    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
+
+    ijk = indexer.get_indices(cellno)
+
+    iind = ijk[:, 0]
+    jind = ijk[:, 1]
+    kind = ijk[:, 2]
+
+    mybuffer[iind, jind, kind] = pvalues[cellno]
+
+    mybuffer = ma.masked_greater(mybuffer, UNDEF_INT_LIMIT if discrete else UNDEF_LIMIT)
+
+    result["values"] = mybuffer
+    result["name"] = pname
+
+    if discrete:
+        result["codes"] = _fix_codes(
+            result["values"].reshape(-1).compressed(), roxprop.code_names
+        )
+        logger.info("Fixed codes: %s", result["codes"])
+    return result
+
+
+def export_prop_roxapi(
+    self: GridProperty,
+    project: RoxarProjectType,
+    gname: str,
+    pname: str,
+    realisation: int = 0,
+    casting: Literal["no", "equiv", "safe", "same_kind", "unsafe"] | None = "unsafe",
+) -> None:
+    """Export (i.e. store or save) to a Property icon in RMS via ROXAR API spec."""
+    rox = RoxUtils(project, readonly=False)
+
+    try:
+        roxgrid = rox.project.grid_models[gname]
+        _store_in_roxar(self, pname, roxgrid, realisation, casting)
+
+    except KeyError as keyerror:
+        raise RuntimeError(keyerror)
+
+    if rox._roxexternal:
+        rox.project.save()
+
+    rox.safe_close()
+
+
+def _store_in_roxar(
+    self: GridProperty,
+    pname: str,
+    roxgrid: RoxarGrid3DType,
+    realisation: int,
+    casting: Literal["no", "equiv", "safe", "same_kind", "unsafe"] | None,
+) -> None:
+    """Store property in RMS."""
+    indexer = roxgrid.get_grid(realisation=realisation).grid_indexer
+
+    logger.info("Store in RMS...")
+
+    val3d = self.values.copy()
+
+    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
+
+    ijk = indexer.get_indices(cellno)
+
+    iind = ijk[:, 0]
+    jind = ijk[:, 1]
+    kind = ijk[:, 2]
+
+    dtype = self._roxar_dtype
+    logger.info("DTYPE is %s for %s", dtype, pname)
+
+    # casting will secure correct types
+    if dtype not in VALID_ROXAR_DTYPES:
+        raise TypeError(
+            f"Roxar dtype is not valid: {dtype} must be in {VALID_ROXAR_DTYPES}"
+        )
+
+    pvalues = roxgrid.get_grid(realisation=realisation).generate_values(data_type=dtype)
+
+    roxtype: Any = roxar  # needed for mypy
+    roxar_property_type = (
+        roxtype.GridPropertyType.discrete
+        if self.isdiscrete
+        else roxtype.GridPropertyType.continuous
+    )
+
+    pvalues[cellno] = val3d[iind, jind, kind]
+
+    properties = roxgrid.properties
+
+    if pname not in properties:
+        rprop = properties.create(
+            pname, property_type=roxar_property_type, data_type=dtype
+        )
+    else:
+        rprop = properties[pname]
+        dtype = rprop.data_type
+
+    rprop.set_values(pvalues.astype(dtype, casting=casting), realisation=realisation)
+
+    if self.isdiscrete:
+        rprop.code_names = _rox_compatible_codes(self.codes)
+
+
+def _fix_codes(
+    active_values: np.ndarray, codes: dict[str | int, str]
+) -> dict[int, str]:
+    """Roxar may provide a code list with empty strings values, fix this issue here.
+
+    Roxar may also interpolate code values which are actually not present in the
+    property. Here, the presence of actual codes is also checked.
+    """
+    newcodes = {}
+    codes_data = {val: str(val) for val in np.unique(active_values)}
+
+    for code, name in codes.items():
+        if not isinstance(code, int):
+            code = int(code)
+
+        if not name:
+            name = str(code)
+
+        if code not in codes_data:
+            continue
+
+        newcodes[code] = name
+
+    return newcodes
+
+
+def _rox_compatible_codes(codes: dict) -> dict:
+    """Ensure that keys in codes are int's prior to storage in RMS."""
+
+    newcodes = {}
+    for code, name in codes.items():
+        if code is None:
+            continue  # skip codes of type None; assumed to be spurious
+        if not isinstance(code, int):
+            try:
+                code = int(code)
+            except ValueError:
+                raise ValueError(
+                    "The keys in codes must be an integer prior to RMS "
+                    f"storage. Actual key found here is '{code}' of type {type(code)}"
+                )
+
+        newcodes[code] = name
+    return newcodes

xtgeo/grid3d/_gridprop_value_init.py

@@ -0,0 +1,140 @@
+"""GridProperty (not GridProperies) some etc functions"""
+
+from __future__ import annotations
+
+import numbers
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+import xtgeo
+from xtgeo.common import null_logger
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid, GridProperty
+
+
+def gridproperty_non_dummy_values(
+    gridlike: Grid | GridProperty | None,
+    dimensions: tuple[int, int, int],
+    values: np.ndarray | float | int | None,
+    isdiscrete: bool,
+) -> np.ma.MaskedArray:
+    """
+    Gives the initial values array of an gridprop.
+
+    Args:
+        gridlike: Either Grid or GridProperty, giving the mask to replicate.
+        dimensions: The (ncol, nrow, nlay) dimensions of the grid property.
+        values: The values parameter given to init.
+        isdiscrete: The discrete parameter given to init.
+
+    Returns:
+        The array to be set to GridProperty._values.
+
+    """
+    if values is None:
+        _values = initial_gridprop_values_zero(dimensions, isdiscrete)
+    elif isinstance(values, numbers.Number):
+        _values = initial_gridprop_values_from_scalar(dimensions, values, isdiscrete)
+    elif isinstance(values, np.ndarray):
+        _values = initial_gridprop_values_from_array(dimensions, values, isdiscrete)
+    else:
+        raise ValueError(
+            f"Cannot create GridProperty with values type '{type(values).__name__}.' "
+            "Expected an nd.array, float, int, or None"
+        )
+
+    if gridlike:
+        if isinstance(gridlike, xtgeo.grid3d.Grid):
+            act = gridlike.get_actnum(asmasked=True)
+            _values = np.ma.array(_values, mask=np.ma.getmaskarray(act.values))
+        else:
+            assert isinstance(gridlike, xtgeo.grid3d.GridProperty)
+            _values = np.ma.array(_values, mask=np.ma.getmaskarray(gridlike.values))
+
+    return _values
+
+
+def gridproperty_dummy_values(isdiscrete: bool) -> np.ma.MaskedArray:
+    """
+    Given no parameters to init, these dummy values should be set for backwards
+    compatability.
+
+    Args:
+        isdiscrete: If the grid property values are discrete.
+
+    Returns:
+        The array to be set to GridProperty._values.
+
+    """
+    values: np.ma.MaskedArray = np.ma.MaskedArray(
+        np.full((4, 3, 5), 99.0), dtype=np.int32 if isdiscrete else np.float64
+    )
+    values[0:4, 0, 0:2] = np.ma.masked
+    return values
+
+
+def initial_gridprop_values_zero(
+    dimensions: tuple[int, int, int], isdiscrete: bool
+) -> np.ma.MaskedArray:
+    """
+    Initial values for an GridProperty with zeros.
+
+    Given that the user supplies at least some parameters, but not a values array,
+    values should be initialized to zero.
+
+    Args:
+        dimensions: The (ncol, nrow, nlay) dimensions of the grid property.
+
+    Returns:
+        Zero initialized values array.
+
+    """
+    return np.ma.zeros(dimensions, dtype=np.int32 if isdiscrete else np.float64)
+
+
+def initial_gridprop_values_from_scalar(
+    dimensions: tuple[int, int, int], value: float | int, isdiscrete: bool
+) -> np.ma.MaskedArray:
+    """
+    Initial grid property values from scalar.
+
+    Given scalar values, the gridproperties value array should be
+    filled with that value, with possible conversion depending
+    on the isdiscrete parameter.
+
+    Args:
+        dimensions: The (ncol, nrow, nlay) dimensions of the grid property.
+        value: The scalar value to initialize with.
+        isdiscrete: If the values are discrete.
+
+    Returns:
+        Filled array with given scalar value.
+
+    """
+    if not isinstance(value, numbers.Number):
+        raise ValueError("Scalar input values of invalid type")
+    return np.ma.zeros(dimensions, dtype=np.int32 if isdiscrete else np.float64) + value
+
+
+def initial_gridprop_values_from_array(
+    dimensions: tuple[int, int, int], values: np.ndarray, isdiscrete: bool
+) -> np.ma.MaskedArray:
+    """
+    Initial GridProperty values from numpy array.
+
+    Args:
+        dimensions: The (ncol, nrow, nlay) dimensions of the grid property.
+        value: The numpy array to initialize with.
+        isdiscrete: If the values are discrete.
+
+    Returns:
+        GridProperty with values initialized from a numpy array.
+
+    """
+    return np.ma.MaskedArray(
+        values.reshape(dimensions), dtype=np.int32 if isdiscrete else np.float64
+    )