xtgeo 4.13.1__cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/surface/_regsurf_gridding.py

@@ -0,0 +1,347 @@
+"""Do gridding from 3D parameters"""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+import numpy.ma as ma
+import scipy.interpolate
+import scipy.ndimage
+
+from xtgeo.common.constants import UNDEF, UNDEF_LIMIT
+from xtgeo.common.log import null_logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from xtgeo.surface import RegularSurface
+
+logger = null_logger(__name__)
+
+# Note: 'self' is an instance of RegularSurface
+
+
+def points_gridding(self, points, method="linear", coarsen=1):
+    """Do gridding from a points data set."""
+
+    xiv, yiv = self.get_xy_values()
+
+    dfra = points.get_dataframe(copy=False)
+
+    xcv = dfra[points.xname].values
+    ycv = dfra[points.yname].values
+    zcv = dfra[points.zname].values
+
+    if coarsen > 1:
+        xcv = xcv[::coarsen]
+        ycv = ycv[::coarsen]
+        zcv = zcv[::coarsen]
+
+    validmethods = ["linear", "nearest", "cubic"]
+    if method not in set(validmethods):
+        raise ValueError(
+            f"Invalid method for gridding: {method}, valid options are {validmethods}"
+        )
+
+    try:
+        znew = scipy.interpolate.griddata(
+            (xcv, ycv), zcv, (xiv, yiv), method=method, fill_value=np.nan
+        )
+    except ValueError as verr:
+        raise RuntimeError(f"Could not do gridding: {verr}")
+
+    logger.info("Gridding point ... DONE")
+
+    self._ensure_correct_values(znew)
+
+
+def avgsum_from_3dprops_gridding(
+    self,
+    summing=False,
+    xprop=None,
+    yprop=None,
+    mprop=None,
+    dzprop=None,
+    truncate_le=None,
+    zoneprop=None,
+    zone_minmax=None,
+    coarsen=1,
+    zone_avg=False,
+    mask_outside=False,
+):
+    """Get surface average from a 3D grid prop."""
+    # NOTE:
+    # This do _either_ averaging _or_ sum gridding (if summing is True)
+    # - Inputs shall be pure 3D numpies, not masked!
+    # - Xprop and yprop must be made for all cells
+    # - Also dzprop for all cells, and dzprop = 0 for inactive cells!
+
+    logger.info("Avgsum calculation %s", __name__)
+
+    if zone_minmax is None:
+        raise ValueError("zone_minmax is required")
+
+    if dzprop is None:
+        raise ValueError("DZ property is required")
+
+    xprop, yprop, zoneprop, mprop, dzprop = _zone_averaging(
+        xprop,
+        yprop,
+        zoneprop,
+        zone_minmax,
+        coarsen,
+        zone_avg,
+        dzprop,
+        mprop,
+        summing=summing,
+    )
+
+    gnlay = xprop.shape[2]
+
+    # avoid artifacts from inactive cells that slips through somehow...(?)
+    if dzprop.max() > UNDEF_LIMIT:
+        raise RuntimeError("Bug: DZ with unphysical values present")
+
+    trimbydz = False
+    if not summing:
+        trimbydz = True
+
+    if summing and mask_outside:
+        trimbydz = True
+
+    xiv, yiv = self.get_xy_values()
+
+    # weight are needed if zoneprop is not follow layers, but rather regions
+    weights = dzprop.copy() * 0.0 + 1.0
+    weights[zoneprop < zone_minmax[0]] = 0.0
+    weights[zoneprop > zone_minmax[1]] = 0.0
+
+    # this operation is needed if zoneprop is aka a region ("irregular zone")
+    zoneprop = ma.masked_less(zoneprop, zone_minmax[0])
+    zoneprop = ma.masked_greater(zoneprop, zone_minmax[1])
+
+    for klay0 in range(gnlay):
+        k1lay = klay0 + 1
+
+        if k1lay == 1:
+            msum = np.zeros((self.ncol, self.nrow), order="C")
+            dzsum = np.zeros((self.ncol, self.nrow), order="C")
+
+        numz = zoneprop[::, ::, klay0].mean()
+        if isinstance(numz, float):
+            numz = int(round(zoneprop[::, ::, klay0].mean()))
+            if numz < zone_minmax[0] or numz > zone_minmax[1]:
+                continue
+        else:
+            continue
+
+        qmcompute = True
+        if summing:
+            propsum = mprop[:, :, klay0].sum()
+            if abs(propsum) < 1e-12:
+                logger.info("Too little HC, skip layer K = %s", k1lay)
+                qmcompute = False
+            else:
+                logger.debug("Z property sum is %s", propsum)
+
+        logger.info("Mapping for layer or zone %s ....", k1lay)
+
+        xcv = xprop[::, ::, klay0].ravel(order="C")
+        ycv = yprop[::, ::, klay0].ravel(order="C")
+        mvv = mprop[::, ::, klay0].ravel(order="C")
+        dzv = dzprop[::, ::, klay0].ravel(order="C")
+        wei = weights[::, ::, klay0].ravel(order="C")
+
+        # this is done to avoid problems if undef values still remains
+        # in the coordinates (assume Y undef where X undef):
+        xcc = xcv.copy()
+        xcv = xcv[xcc < 1e20]
+        ycv = ycv[xcc < 1e20]
+        mvv = mvv[xcc < 1e20]
+        dzv = dzv[xcc < 1e20]
+        wei = wei[xcc < 1e20]
+
+        mvdz = mvv * wei if summing else mvv * dzv * wei
+
+        if qmcompute:
+            try:
+                mvdzi = scipy.interpolate.griddata(
+                    (xcv, ycv), mvdz, (xiv, yiv), method="linear", fill_value=0.0
+                )
+            except ValueError:
+                warnings.warn("Some problems in gridding ... will contue", UserWarning)
+                continue
+
+            msum = msum + mvdzi
+
+        if trimbydz:
+            try:
+                dzi = scipy.interpolate.griddata(
+                    (xcv, ycv), dzv, (xiv, yiv), method="linear", fill_value=0.0
+                )
+            except ValueError:
+                continue
+
+            dzsum = dzsum + dzi
+
+    if not summing:
+        dzsum[dzsum == 0.0] = 1e-20
+        vvz = msum / dzsum
+        vvz = ma.masked_invalid(vvz)
+    else:
+        vvz = msum
+
+    vvz = (
+        ma.masked_where(dzsum < 1.1e-20, vvz) if trimbydz else ma.array(vvz)
+    )  # so the result becomes a ma array
+
+    if truncate_le:
+        vvz = ma.masked_less(vvz, truncate_le)
+
+    self.values = vvz
+    logger.info("Avgsum calculation done! %s", __name__)
+
+    return True
+
+
+def _zone_averaging(
+    xprop, yprop, zoneprop, zone_minmax, coarsen, zone_avg, dzprop, mprop, summing=False
+):
+    # General preprocessing, and...
+    # Change the 3D numpy array so they get layers by
+    # averaging across zones. This may speed up a lot,
+    # but will reduce the resolution.
+    # The x y coordinates shall be averaged (ideally
+    # with thickness weighting...) while e.g. hcpfzprop
+    # must be summed.
+    # Somewhat different processing whether this is a hc thickness
+    # or an average.
+
+    xpr = xprop
+    ypr = yprop
+    zpr = zoneprop
+    dpr = dzprop
+
+    mpr = mprop
+
+    if coarsen > 1:
+        xpr = xprop[::coarsen, ::coarsen, ::].copy(order="C")
+        ypr = yprop[::coarsen, ::coarsen, ::].copy(order="C")
+        zpr = zoneprop[::coarsen, ::coarsen, ::].copy(order="C")
+        dpr = dzprop[::coarsen, ::coarsen, ::].copy(order="C")
+        mpr = mprop[::coarsen, ::coarsen, ::].copy(order="C")
+        zpr.astype(np.int32)
+
+    if zone_avg:
+        zmin = int(zone_minmax[0])
+        zmax = int(zone_minmax[1])
+        if zpr.min() > zmin:
+            zmin = zpr.min()
+        if zpr.max() < zmax:
+            zmax = zpr.max()
+
+        newx = []
+        newy = []
+        newz = []
+        newm = []
+        newd = []
+
+        for izv in range(zmin, zmax + 1):
+            logger.info("Averaging for zone %s ...", izv)
+            xpr2 = ma.masked_where(zpr != izv, xpr)
+            ypr2 = ma.masked_where(zpr != izv, ypr)
+            zpr2 = ma.masked_where(zpr != izv, zpr)
+            dpr2 = ma.masked_where(zpr != izv, dpr)
+            mpr2 = ma.masked_where(zpr != izv, mpr)
+
+            # get the thickness and normalize along axis 2 (vertical)
+            # to get normalized thickness weights
+            lay_sums = dpr2.sum(axis=2)
+            normed_dz = dpr2 / lay_sums[:, :, np.newaxis]
+
+            # assume that coordinates have equal weights within a zone
+            xpr2 = ma.average(xpr2, axis=2)
+            ypr2 = ma.average(ypr2, axis=2)
+            zpr2 = ma.average(zpr2, axis=2)  # avg zone
+
+            dpr2 = ma.sum(dpr2, axis=2)
+
+            if summing:
+                mpr2 = ma.sum(mpr2, axis=2)
+            else:
+                mpr2 = ma.average(mpr2, weights=normed_dz, axis=2)  # avg zone
+
+            newx.append(xpr2)
+            newy.append(ypr2)
+            newz.append(zpr2)
+            newd.append(dpr2)
+            newm.append(mpr2)
+
+        xpr = ma.dstack(newx)
+        ypr = ma.dstack(newy)
+        zpr = ma.dstack(newz)
+        dpr = ma.dstack(newd)
+        mpr = ma.dstack(newm)
+        zpr.astype(np.int32)
+
+    xpr = ma.filled(xpr, fill_value=UNDEF)
+    ypr = ma.filled(ypr, fill_value=UNDEF)
+    zpr = ma.filled(zpr, fill_value=0)
+    dpr = ma.filled(dpr, fill_value=0.0)
+
+    mpr = ma.filled(mpr, fill_value=0.0)
+
+    return xpr, ypr, zpr, mpr, dpr
+
+
+def surf_fill(self, fill_value=None):
+    """Replace the value of invalid 'data' cells (indicated by 'invalid')
+    by the value of the nearest valid data cell or a constant.
+
+    This is a quite fast method to fill undefined areas of the map.
+    The surface values are updated 'in-place'
+
+    .. versionadded:: 2.1
+    .. versionchanged:: 2.6 Added fill_value
+    """
+    logger.info("Do fill...")
+
+    if fill_value is not None:
+        if np.isscalar(fill_value) and not isinstance(fill_value, str):
+            self.values = ma.filled(self.values, fill_value=float(fill_value))
+        else:
+            raise ValueError("Keyword fill_value must be int or float")
+    else:
+        invalid = ma.getmaskarray(self.values)
+
+        ind = scipy.ndimage.distance_transform_edt(
+            invalid, return_distances=False, return_indices=True
+        )
+        self._values = self._values[tuple(ind)]
+        logger.info("Do fill... DONE")
+
+
+def _smooth(
+    self: RegularSurface,
+    window_function: Callable[[np.ndarray], np.ndarray],
+    iterations: int = 1,
+) -> None:
+    """
+    Smooth a RegularSurface using a window function.
+
+    Original mask (undefined values) is stored before applying
+    smoothing on a filled array. Subsequently the original mask
+    is used to restore the undefined values in the output.
+    """
+
+    mask = ma.getmaskarray(self.values)
+
+    self.fill()
+
+    smoothed_values = self.values
+    for _ in range(iterations):
+        smoothed_values = window_function(smoothed_values, mode="nearest")
+
+    self.values = ma.array(smoothed_values, mask=mask)

xtgeo/surface/_regsurf_ijxyz_parser.py

@@ -0,0 +1,278 @@
+"""IJXYZ files (OW/DSG) parsing.
+
+This format lacks explicit information such as origin, xinc, yinc, rotation etc; i.e.
+all these setting must be computed from the input.
+
+Missing inline and xline values are assumed to be undefined. Examples:
+
+
+========================================================================================
+815	1210	777574.220000	6736507.760000	1010.000000
+816	1210	777561.894910	6736521.890000	1010.000000
+817	1210	777549.569820	6736536.020000	1010.000000
+818	1210	777537.244731	6736550.150000	1010.000000
+819	1210	777524.919641	6736564.280000	1010.000000
+820	1210	777512.594551	6736578.410000	1010.000000
+821	1210	777500.269461	6736592.540000	1010.000000
+822	1210	777487.944371	6736606.670000	1010.000000
+823	1210	777475.619281	6736620.800000	1010.000000
+...
+846	1211	777201.561266	6736954.005898	1010.000000
+847	1211	777189.236176	6736968.135898	1010.000000
+848	1211	777176.911086	6736982.265898	1010.000000
+849	1211	777164.585996	6736996.395898	1010.000000
+850	1211	777152.260906	6737010.525898	1010.000000
+851	1211	777139.935817	6737024.655898	1010.000000
+...
+
+Here inline is fastest and increasing and every inline and xline is applied
+
+========================================================================================
+
+24	3	774906.625000	6736030.500000	1741.107300
+26	3	774946.017310	6736023.554073	1730.530884
+28	3	774985.409620	6736016.608146	1719.947876
+30	3	775024.801930	6736009.662219	1709.229370
+32	3	775064.194240	6736002.716292	1698.470337
+34	3	775103.586551	6735995.770364	1687.320435
+...
+272	3	779791.271455	6735169.205039	1404.342041
+274	3	779830.663765	6735162.259112	1413.154175
+24	6	774915.307409	6736079.740388	1727.455078
+26	6	774954.699719	6736072.794461	1719.031128
+28	6	774994.092029	6736065.848533	1710.606201
+30	6	775033.484339	6736058.902606	1702.161255
+32	6	775072.876649	6736051.956679	1693.707153
+34	6	775112.268959	6736045.010752	1685.164673
+
+Here every second inline and every third xline is applied
+
+========================================================================================
+
+ 1312  2015   655905.938642   6627044.343360   1671.420800
+ 1312  2010   655858.839186   6627003.259513   1669.091400
+ 1302  2028   656151.649337   6627009.862811   1680.437500
+ 1312  2011   655868.259077   6627011.476282   1669.444000
+ 1302  2029   656161.069228   6627018.079581   1681.000000
+ 1302  2026   656132.809555   6626993.429272   1679.312500
+ 1302  2027   656142.229446   6627001.646042   1679.875000
+ 1302  2024   656113.969773   6626976.995733   1678.187500
+ 1302  2025   656123.389664   6626985.212503   1678.750000
+
+This seems to lack obvious patterns (mostly due to many undefied cells?). Hence we
+need to detect minimum spacing and min/max of both ilines and xlines, unless a template
+is applied.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal, Optional
+
+import numpy as np
+from numpy.ma import MaskedArray
+
+from xtgeo.common.calc import find_flip, xyori_from_ij
+from xtgeo.common.log import null_logger
+
+if TYPE_CHECKING:
+    from xtgeo.cube.cube1 import Cube
+
+    from .regular_surface import RegularSurface
+
+logger = null_logger(__name__)
+
+
+@dataclass
+class SurfaceIJXYZ:
+    """Temporary class for parsing IJXYZ settings.
+
+    Attributes:
+        xcoords_in: Input X coordinates.
+        ycoords_in: Input Y coordinates.
+        values_in: Input values.
+        ilines_in: Input inline values.
+        xlines_in: Input crossline values.
+        template: Geometrical template.
+    """
+
+    xcoords_in: MaskedArray
+    ycoords_in: MaskedArray
+    values_in: MaskedArray
+    ilines_in: np.ndarray
+    xlines_in: np.ndarray
+    template: Optional[RegularSurface | Cube] = None
+
+    ncol: int = field(default=1, init=False)
+    nrow: int = field(default=1, init=False)
+    xori: float = field(default=0.0, init=False)
+    yori: float = field(default=0.0, init=False)
+    xinc: float = field(default=1.0, init=False)
+    yinc: float = field(default=1.0, init=False)
+    yflip: Literal[-1, 1] = field(default=1, init=False)
+    xcoords: MaskedArray = field(default_factory=MaskedArray, init=False)
+    ycoords: MaskedArray = field(default_factory=MaskedArray, init=False)
+    values: MaskedArray = field(default_factory=MaskedArray, init=False)
+    ilines: np.ndarray = field(default_factory=lambda: np.zeros(1), init=False)
+    xlines: np.ndarray = field(default_factory=lambda: np.zeros(1), init=False)
+
+    def __post_init__(self) -> None:
+        self._parse_arrays()
+        if self.template:
+            self._map_on_template()
+        else:
+            self._calculate_geometrics()
+
+    def _parse_arrays(self) -> None:
+        """Parse input and arrange basic data and arrays."""
+
+        logger.debug("Parse ijxyz arrays")
+        # both ilines and xlines may jump e.g. every second; detect minimum jump:
+        inline_mindiff = int(np.min(np.diff(np.unique(np.sort(self.ilines_in)))))
+        xline_mindiff = int(np.min(np.diff(np.unique(np.sort(self.xlines_in)))))
+
+        i_index = np.divide(self.ilines_in, inline_mindiff)
+        i_index = (i_index - i_index.min()).astype("int32")
+
+        j_index = np.divide(self.xlines_in, xline_mindiff)
+        j_index = (j_index - j_index.min()).astype("int32")
+
+        self.ncol = int(i_index.max() + 1)
+        self.nrow = int(j_index.max() + 1)
+
+        self.ilines = np.array(
+            range(
+                self.ilines_in.min(),
+                self.ilines_in.max() + inline_mindiff,
+                inline_mindiff,
+            )
+        ).astype("int32")
+
+        self.xlines = np.array(
+            range(
+                self.xlines_in.min(),
+                self.xlines_in.max() + xline_mindiff,
+                xline_mindiff,
+            )
+        ).astype("int32")
+
+        shape = (self.ncol, self.nrow)
+
+        xvalues = np.full(shape, np.nan)
+        xvalues[i_index, j_index] = self.xcoords_in
+        self.xcoords = np.ma.masked_invalid(xvalues)
+
+        yvalues = np.full(shape, np.nan)
+        yvalues[i_index, j_index] = self.ycoords_in
+        self.ycoords = np.ma.masked_invalid(yvalues)
+
+        zvalues = np.full(shape, np.nan)
+        zvalues[i_index, j_index] = self.values_in
+        self.values = np.ma.masked_invalid(zvalues)
+
+    def _map_on_template(self) -> None:
+        """An existing RegularSurface or Cube forms the geometrical template."""
+        logger.debug("Parse ijxyz with template")
+
+        # TODO: Remove these when moved to xtgeo.io
+        from xtgeo.cube.cube1 import Cube
+
+        from .regular_surface import RegularSurface
+
+        if not isinstance(self.template, (RegularSurface, Cube)):
+            raise ValueError(
+                "The provided template is not of type RegularSurface or Cube"
+            )
+
+        ilines_orig = self.ilines.copy()
+        xlines_orig = self.xlines.copy()
+
+        il_step = int(np.diff(np.sort(ilines_orig)).min())
+        xl_step = int(np.diff(np.sort(xlines_orig)).min())
+
+        # now ovveride with settings from template
+        for attr in (
+            "ncol",
+            "nrow",
+            "xori",
+            "yori",
+            "xinc",
+            "yinc",
+            "rotation",
+            "yflip",
+            "ilines",
+            "xlines",
+        ):
+            setattr(self, attr, getattr(self.template, attr))
+
+        i_start = abs(int((self.ilines.min() - ilines_orig.min()) / il_step))
+        j_start = abs(int((self.xlines.min() - xlines_orig.min()) / xl_step))
+
+        shape = (self.ncol, self.nrow)
+
+        zvalues = np.full(shape, np.nan)
+        zvalues[
+            i_start : i_start + self.values.shape[0],
+            j_start : j_start + self.values.shape[1],
+        ] = np.ma.filled(self.values, fill_value=np.nan)
+
+        self.values = np.ma.masked_invalid(zvalues)
+
+    def _calculate_geometrics(self) -> None:
+        """Compute the geometrics such as rotation, flip origin and increments."""
+
+        logger.debug("Compute ijxyz geometrics from arrays")
+        # along_east and along_north here refers to the case when rotation is 0.0
+        dx_along_east = np.diff(self.xcoords, axis=0)
+        dy_along_east = np.diff(self.ycoords, axis=0)
+        dx_along_north = np.diff(self.xcoords, axis=1)
+        dy_along_north = np.diff(self.ycoords, axis=1)
+
+        self.yflip = find_flip(
+            (dx_along_east.mean(), dy_along_east.mean(), 0.0),
+            (dx_along_north.mean(), dy_along_north.mean(), 0.0),
+        )
+
+        self.rotation = float(
+            np.degrees(np.arctan2(dy_along_east, dx_along_east)).mean()
+        )
+
+        distances_xinc = np.sqrt(dx_along_east**2 + dy_along_east**2)
+        distances_yinc = np.sqrt(dx_along_north**2 + dy_along_north**2)
+        self.xinc = float(distances_xinc.mean())
+        self.yinc = float(distances_yinc.mean())
+
+        cols, rows = np.ma.where(~self.xcoords.mask)  # get active indices
+
+        first_active_col = int(cols[0])
+        first_active_row = int(rows[0])
+
+        self.xori, self.yori = xyori_from_ij(
+            first_active_col,
+            first_active_row,
+            self.xcoords[first_active_col, first_active_row],
+            self.ycoords[first_active_col, first_active_row],
+            self.xinc,
+            self.yinc,
+            self.ncol,
+            self.nrow,
+            self.yflip,
+            float(self.rotation),
+        )
+
+
+def parse_ijxyz(mfile, template=None) -> tuple:
+    """Read IJXYZ data file and parse the content."""
+
+    if mfile.memstream:
+        mfile.file.seek(0)
+
+    data = np.loadtxt(mfile.file, comments=["@", "#", "EOB"])
+
+    inline = data[:, 0].astype("int32")
+    xline = data[:, 1].astype("int32")
+    x_arr = data[:, 2].astype("float64")
+    y_arr = data[:, 3].astype("float64")
+    z_arr = data[:, 4].astype("float64")
+
+    return SurfaceIJXYZ(x_arr, y_arr, z_arr, inline, xline, template=template)