xtgeo 4.14.0__cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/surface/_regsurf_cube_window.py

@@ -0,0 +1,391 @@
+"""Regular surface vs Cube, slice a window interval"""
+
+import numpy as np
+import numpy.ma as ma
+
+from xtgeo.common.log import null_logger
+from xtgeo.common.xtgeo_dialog import XTGShowProgress
+
+from . import _regsurf_cube_window_v2 as cwv2, _regsurf_cube_window_v3 as cwv3
+
+logger = null_logger(__name__)
+
+
+ALLATTRS = [
+    "max",
+    "min",
+    "rms",
+    "mean",
+    "var",
+    "maxpos",
+    "maxneg",
+    "maxabs",
+    "sumpos",
+    "sumneg",
+    "sumabs",
+    "meanabs",
+    "meanpos",
+    "meanneg",
+]
+
+
+def slice_cube_window(
+    self,
+    cube,
+    scube,
+    zsurf=None,
+    other=None,
+    other_position="below",
+    sampling="nearest",
+    mask=True,
+    zrange=10,
+    ndiv=None,
+    attribute="max",
+    maskthreshold=0.1,
+    snapxy=False,
+    showprogress=False,
+    deadtraces=True,
+    algorithm=1,
+):
+    if algorithm == 1:
+        if sampling == "cube":
+            sampling = "nearest"
+
+        attrs = _slice_cube_window_v1(
+            self,
+            cube,
+            zsurf=zsurf,
+            other=other,
+            other_position=other_position,
+            sampling=sampling,
+            mask=mask,
+            zrange=zrange,
+            ndiv=ndiv,
+            attribute=attribute,
+            maskthreshold=maskthreshold,
+            snapxy=snapxy,
+            showprogress=showprogress,
+            deadtraces=deadtraces,
+        )
+
+    elif algorithm == 2:
+        attrs = cwv2.slice_cube_window(
+            self,
+            cube,
+            scube,
+            zsurf=zsurf,
+            other=other,
+            other_position=other_position,
+            sampling=sampling,
+            mask=mask,
+            zrange=zrange,
+            ndiv=ndiv,
+            attribute=attribute,
+            maskthreshold=maskthreshold,
+            snapxy=snapxy,
+            showprogress=showprogress,
+            deadtraces=deadtraces,
+        )
+    else:
+        attrs = cwv3.slice_cube_window(
+            self,
+            cube,
+            scube,
+            zsurf=zsurf,
+            other=other,
+            other_position=other_position,
+            sampling=sampling,
+            mask=mask,
+            zrange=zrange,
+            ndiv=ndiv,
+            attribute=attribute,
+            maskthreshold=maskthreshold,
+            snapxy=snapxy,
+            showprogress=showprogress,
+            deadtraces=deadtraces,
+        )
+    return attrs
+
+
+def _slice_cube_window_v1(
+    self,
+    cube,
+    zsurf=None,
+    other=None,
+    other_position="below",
+    sampling="nearest",
+    mask=True,
+    zrange=10,
+    ndiv=None,
+    attribute="max",
+    maskthreshold=0.1,
+    snapxy=False,
+    showprogress=False,
+    deadtraces=True,
+):
+    """Slice Cube with a window and extract attribute(s)
+
+    This is legacy version algorithm 1 and will removed later.
+
+    The zrange is one-sided (on order to secure a centered input); hence
+    of zrange is 5 than the fill window is 10.
+
+    The maskthreshold is only valid for surfaces; if isochore is less than
+    given value then the result will be masked.
+
+    Note: attribute may be a scalar or a list. If a list, then a dict of
+    surfaces are returned.
+    """
+    logger.info("Slice cube window method")
+
+    qattr_is_string = True
+    if not isinstance(attribute, list):
+        if attribute == "all":
+            attrlist = ALLATTRS
+            qattr_is_string = False
+        else:
+            attrlist = [attribute]
+    else:
+        attrlist = attribute
+        qattr_is_string = False
+
+    this = zsurf if zsurf is not None else self.copy()
+
+    if other is not None:
+        zdelta = np.absolute(this.values - other.values)
+        zrange = zdelta.max()
+
+    ndivmode = "user setting"
+    if ndiv is None:
+        ndivmode = "auto"
+        ndiv = int(2 * zrange / cube.zinc)
+        if ndiv < 1:
+            ndiv = 1
+            logger.warning("NDIV < 1; reset to 1")
+
+    logger.info("ZRANGE is %s", zrange)
+    logger.info("NDIV is set to %s (%s)", ndiv, ndivmode)
+
+    # This will run slice in a loop within a window. Then, numpy methods
+    # are applied to get the attributes
+
+    if other is None:
+        attvalues = _slice_constant_window(
+            this,
+            cube,
+            sampling,
+            zrange,
+            ndiv,
+            mask,
+            attrlist,
+            snapxy,
+            showprogress=showprogress,
+            deadtraces=deadtraces,
+        )
+    else:
+        attvalues = _slice_between_surfaces(
+            this,
+            cube,
+            sampling,
+            other,
+            other_position,
+            zrange,
+            ndiv,
+            mask,
+            attrlist,
+            maskthreshold,
+            snapxy,
+            showprogress=showprogress,
+            deadtraces=deadtraces,
+        )
+
+    results = {}
+
+    for attr in attrlist:
+        scopy = self.copy()
+        scopy.values = attvalues[attr]
+        results[attr] = scopy
+
+    # for backward compatibility
+    if qattr_is_string:
+        self.values = attvalues[attrlist[0]]
+        return None
+
+    return results
+
+
+def _slice_constant_window(
+    this,
+    cube,
+    sampling,
+    zrange,
+    ndiv,
+    mask,
+    attrlist,
+    snapxy,
+    showprogress=False,
+    deadtraces=True,
+):
+    """Slice a window, (constant in vertical extent)."""
+    npcollect = []
+    zcenter = this.copy()
+
+    logger.info("Mean W of depth no MIDDLE slice is %s", zcenter.values.mean())
+    zcenter.slice_cube(
+        cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces
+    )
+    logger.info("Mean of cube slice is %s", zcenter.values.mean())
+
+    npcollect.append(zcenter.values)
+
+    zincr = zrange / float(ndiv)
+
+    logger.info("ZINCR is %s", zincr)
+
+    # collect above the original surface
+    progress = XTGShowProgress(
+        ndiv * 2, show=showprogress, leadtext="progress: ", skip=1
+    )
+    for idv in range(ndiv):
+        progress.flush(idv)
+        ztmp = this.copy()
+        ztmp.values -= zincr * (idv + 1)
+        ztmp.slice_cube(
+            cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces
+        )
+        npcollect.append(ztmp.values)
+    # collect below the original surface
+    for idv in range(ndiv):
+        progress.flush(ndiv + idv)
+        ztmp = this.copy()
+        ztmp.values += zincr * (idv + 1)
+        ztmp.slice_cube(
+            cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces
+        )
+        npcollect.append(ztmp.values)
+
+    logger.info("Make a stack of the maps...")
+    stacked = ma.dstack(npcollect)
+    del npcollect
+
+    attvalues = {}
+    for attr in attrlist:
+        logger.info("Running attribute %s", attr)
+        attvalues[attr] = _attvalues(attr, stacked)
+
+    progress.finished()
+    return attvalues  # this is dict with numpies, one per attribute
+
+
+def _slice_between_surfaces(
+    this,
+    cube,
+    sampling,
+    other,
+    other_position,
+    zrange,
+    ndiv,
+    mask,
+    attrlist,
+    mthreshold,
+    snapxy,
+    showprogress=False,
+    deadtraces=True,
+):
+    """Slice and find values between two surfaces."""
+
+    npcollect = []
+    zincr = zrange / float(ndiv)
+
+    zcenter = this.copy()
+    zcenter.slice_cube(
+        cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces
+    )
+    npcollect.append(zcenter.values)
+
+    # collect below or above the original surface
+    mul = -1 if other_position == "above" else 1
+
+    # collect above the original surface
+    progress = XTGShowProgress(ndiv, show=showprogress, leadtext="progress: ")
+    for idv in range(ndiv):
+        progress.flush(idv)
+        ztmp = this.copy()
+        ztmp.values += zincr * (idv + 1) * mul
+        zvalues = ztmp.values.copy()
+
+        ztmp.slice_cube(
+            cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces
+        )
+
+        diff = mul * (other.values - zvalues)
+
+        values = ztmp.values
+        values = ma.masked_where(diff < 0.0, values)
+
+        npcollect.append(values)
+
+    stacked = ma.dstack(npcollect)
+
+    del npcollect
+
+    # for cases with erosion, the two surfaces are equal
+    isovalues = mul * (other.values - this.values)
+
+    attvalues = {}
+    for attr in attrlist:
+        attvaluestmp = _attvalues(attr, stacked)
+        attvalues[attr] = ma.masked_where(isovalues < mthreshold, attvaluestmp)
+
+    progress.finished()
+
+    return attvalues  # this is dict with numpies, one per attribute
+
+
+def _attvalues(attribute, stacked):
+    """Attribute values computed in numpy.ma stack."""
+    if attribute == "max":
+        attvalues = ma.max(stacked, axis=2)
+    elif attribute == "min":
+        attvalues = ma.min(stacked, axis=2)
+    elif attribute == "rms":
+        attvalues = np.sqrt(ma.mean(np.square(stacked), axis=2))
+    elif attribute == "var":
+        attvalues = ma.var(stacked, axis=2)
+    elif attribute == "mean":
+        attvalues = ma.mean(stacked, axis=2)
+    elif attribute == "maxpos":
+        stacked = ma.masked_less(stacked, 0.0, copy=True)
+        attvalues = ma.max(stacked, axis=2)
+    elif attribute == "maxneg":  # ~ minimum of negative values?
+        stacked = ma.masked_greater_equal(stacked, 0.0, copy=True)
+        attvalues = ma.min(stacked, axis=2)
+    elif attribute == "maxabs":
+        attvalues = ma.max(abs(stacked), axis=2)
+    elif attribute == "sumpos":
+        stacked = ma.masked_less(stacked, 0.0, copy=True)
+        attvalues = ma.sum(stacked, axis=2)
+    elif attribute == "sumneg":
+        stacked = ma.masked_greater_equal(stacked, 0.0, copy=True)
+        attvalues = ma.sum(stacked, axis=2)
+    elif attribute == "sumabs":
+        attvalues = ma.sum(abs(stacked), axis=2)
+    elif attribute == "meanabs":
+        attvalues = ma.mean(abs(stacked), axis=2)
+    elif attribute == "meanpos":
+        stacked = ma.masked_less(stacked, 0.0, copy=True)
+        attvalues = ma.mean(stacked, axis=2)
+    elif attribute == "meanneg":
+        stacked = ma.masked_greater_equal(stacked, 0.0, copy=True)
+        attvalues = ma.mean(stacked, axis=2)
+    else:
+        etxt = f"Invalid attribute applied: {attribute}"
+        raise ValueError(etxt)
+
+    if not attvalues.flags["C_CONTIGUOUS"]:
+        mask = ma.getmaskarray(attvalues)
+        mask = np.asanyarray(mask, order="C")
+        attvalues = np.asanyarray(attvalues, order="C")
+        attvalues = ma.array(attvalues, mask=mask, order="C")
+
+    return attvalues

xtgeo/surface/_regsurf_cube_window_v2.py

@@ -0,0 +1,297 @@
+"""Regular surface vs Cube, slice a window interval v2"""
+
+import numpy as np
+
+from xtgeo import _cxtgeo
+from xtgeo.common.constants import UNDEF
+from xtgeo.common.log import null_logger
+
+logger = null_logger(__name__)
+
+
+ALLATTRS = [
+    "min",
+    "max",
+    "mean",
+    "var",
+    "rms",
+    "maxpos",
+    "maxneg",
+    "maxabs",
+    "meanabs",
+    "meanpos",
+    "meanneg",
+    "sumpos",
+    "sumneg",
+    "sumabs",
+]
+
+
+def slice_cube_window(
+    self,
+    cube,
+    scube,
+    zsurf=None,
+    other=None,
+    other_position="below",
+    sampling="nearest",
+    mask=True,
+    zrange=10,
+    ndiv=None,
+    attribute="max",
+    maskthreshold=0.1,
+    snapxy=False,
+    showprogress=False,
+    deadtraces=True,
+):
+    if not snapxy:
+        attrs = _slice_cube_window_resample(
+            self,
+            cube,
+            scube,
+            zsurf,
+            other,
+            other_position,
+            sampling,
+            mask,
+            zrange,
+            ndiv,
+            attribute,
+            maskthreshold,
+            showprogress,
+            deadtraces,
+        )
+
+    else:
+        attrs = _slice_cube_window(
+            self,
+            cube,
+            zsurf,
+            other,
+            other_position,
+            sampling,
+            mask,
+            zrange,
+            ndiv,
+            attribute,
+            maskthreshold,
+            showprogress,
+            deadtraces,
+        )
+
+    # if attribute is str, self shall be updated and None returned, otherwise a dict
+    # of attributes objects shall be returned
+    if isinstance(attrs, dict) and len(attrs) == 1 and isinstance(attribute, str):
+        self.values = attrs[attribute].values
+        return None
+
+    return attrs
+
+
+def _slice_cube_window(
+    self,
+    cube,
+    zsurf,
+    other,
+    other_position,
+    sampling,
+    mask,
+    zrange,
+    ndiv,
+    attribute,
+    maskthreshold,
+    showprogress,
+    deadtraces,
+):
+    """Slice Cube between surfaces to find attributes
+
+    New from May 2020, to provide a much faster algorithm and correct some issues
+    found in previous version
+    """
+
+    logger.info("Slice cube window method v2")
+
+    olddead = None
+    if deadtraces:
+        olddead = cube.values_dead_traces(UNDEF)
+
+    optprogress = 0
+    if showprogress:
+        optprogress = 1
+
+    if not isinstance(attribute, list):
+        attrlist = ALLATTRS if attribute == "all" else [attribute]
+    else:
+        attrlist = attribute
+
+    this = zsurf if zsurf is not None else self.copy()
+
+    if other is not None:
+        zdelta = np.absolute(this.values - other.values)
+        zdiameter = zdelta.max()
+        if other_position.lower() == "below":
+            surf1 = this
+            surf2 = other
+        else:
+            surf1 = other  # BEWARE self
+            surf2 = this
+    else:
+        surf1 = this.copy()
+        surf2 = this.copy()
+        surf1.values -= zrange
+        surf2.values += zrange
+        zdiameter = 2 * zrange
+
+    if ndiv is None:
+        ndiv = int(2 * zdiameter / cube.zinc)
+        if ndiv < 1:
+            ndiv = 1
+            logger.warning("NDIV < 1; reset to 1")
+
+    # force/overrule a coarse sampling for sampling option "cube"
+    ndivdisc = int((zdiameter) * 1.0001 / cube.zinc)
+    if sampling == "cube":
+        ndiv = ndivdisc
+
+    zrinc = zdiameter / ndiv
+    logger.debug("zdiameter and cube zinc: %s %s", zdiameter, cube.zinc)
+    logger.debug("zrinc and ndiv: %s %s", zrinc, ndiv)
+
+    optsum = 0
+    if any("sum" in word for word in attrlist):
+        optsum = 1
+
+    results = _attributes_betw_surfaces(
+        self,
+        cube,
+        surf1,
+        surf2,
+        sampling,
+        mask,
+        zrinc,
+        ndiv,
+        ndivdisc,
+        optprogress,
+        maskthreshold,
+        optsum,
+    )
+
+    if deadtraces:
+        cube.values_dead_traces(olddead)  # reset value for dead traces
+
+    # build the returning result
+    alist = {}
+    for att in attrlist:
+        num = ALLATTRS.index(att)
+        alist[att] = self.copy()
+        alist[att].values = results[num, :]
+
+    return alist
+
+
+def _attributes_betw_surfaces(
+    self,
+    cube,
+    surf1,
+    surf2,
+    sampling,
+    maskopt,
+    zrinc,
+    ndiv,
+    ndivdisc,
+    optprogress,
+    maskthreshold,
+    optsum,
+):
+    """This is the actual lowlevel engine communicating with C code"""
+
+    logger.info("Attributes between surfaces")
+
+    results = np.zeros((len(ALLATTRS) * self.ncol * self.nrow), dtype=np.float64)
+
+    optnearest = 0
+    if sampling in ["nearest", "cube"]:
+        optnearest = 1
+
+    _cxtgeo.surf_cube_attr_intv(
+        cube.ncol,
+        cube.nrow,
+        cube.nlay,
+        cube.zori,
+        cube.zinc,
+        cube.values,
+        surf1.values.data,
+        surf2.values.data,
+        surf1.values.mask,
+        surf2.values.mask,
+        zrinc,
+        ndiv,
+        ndivdisc,
+        results,
+        optnearest,
+        maskopt,
+        optprogress,
+        maskthreshold,
+        optsum,
+    )
+
+    logger.info("Results updated, with size %s", results.shape)
+
+    return results.reshape((len(ALLATTRS), self.ncol * self.nrow), order="C")
+
+
+def _slice_cube_window_resample(
+    self,
+    cube,
+    scube,
+    zsurf,
+    other,
+    other_position,
+    sampling,
+    mask,
+    zrange,
+    ndiv,
+    attribute,
+    maskthreshold,
+    showprogress,
+    deadtraces,
+):
+    """Makes a resample from original surfaces first to fit cube topology"""
+
+    logger.info("Attributes between surfaces, resampling version")
+
+    scube.resample(self)
+
+    szsurf = None
+    if zsurf:
+        szsurf = scube.copy()
+        szsurf.resample(zsurf)
+
+    sother = None
+    if other:
+        sother = scube.copy()
+        sother.resample(other)
+
+    attrs = _slice_cube_window(
+        scube,
+        cube,
+        szsurf,
+        sother,
+        other_position,
+        sampling,
+        mask,
+        zrange,
+        ndiv,
+        attribute,
+        maskthreshold,
+        showprogress,
+        deadtraces,
+    )
+
+    # now resample attrs back to a copy of self
+    zelf = self.copy()
+    for key, _val in attrs.items():
+        zelf.resample(attrs[key])
+        attrs[key] = zelf.copy()
+
+    return attrs