xtgeo 4.13.1__cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/well/_wellmarkers.py

@@ -0,0 +1,486 @@
+"""Well marker data; private module"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from xtgeo import _cxtgeo
+from xtgeo.common.constants import (
+    UNDEF,
+    UNDEF_DISC,
+    UNDEF_INT,
+    UNDEF_INT_LIMIT,
+    UNDEF_LIMIT,
+)
+from xtgeo.common.log import null_logger
+from xtgeo.xyz.points import Points
+
+logger = null_logger(__name__)
+
+
+def get_zonation_points(
+    self: Points, tops, incl_limit, top_prefix, zonelist, use_undef
+):
+    """
+    Getting zonation tops (private routine)
+
+    Args, see calling routine
+    """
+    scopy = self.copy()  # avoid altering original instance
+
+    scopy.geometrics()
+    dataframe = scopy.get_dataframe()
+
+    # as zlog is float64; need to convert to int array with high number as undef
+    if scopy.zonelogname is not None:
+        if use_undef:
+            dataframe.dropna(subset=[scopy.zonelogname], inplace=True)
+        zlog = dataframe[scopy.zonelogname].values
+        zlog[np.isnan(zlog)] = UNDEF_DISC
+        zlog = np.rint(zlog).astype(int)
+    else:
+        return None
+
+    xvv = dataframe[scopy.xname].values
+    yvv = dataframe[scopy.yname].values
+    zvv = dataframe[scopy.zname].values
+    incl = dataframe["Q_INCL"].values
+    mdv = dataframe["Q_MDEPTH"].values
+
+    if scopy.mdlogname is not None:
+        mdv = dataframe[scopy.mdlogname].values
+
+    if zonelist is None:
+        # need to declare as list; otherwise Py3 will get dict.keys
+        zonelist = list(scopy.get_logrecord(scopy.zonelogname).keys())
+
+    logger.debug("Find values for %s", zonelist)
+
+    ztops, ztopnames, zisos, zisonames = _extract_ztops(
+        scopy,
+        zonelist,
+        xvv,
+        yvv,
+        zvv,
+        zlog,
+        mdv,
+        incl,
+        tops=tops,
+        incl_limit=incl_limit,
+        prefix=top_prefix,
+        use_undef=use_undef,
+    )
+
+    zlist = ztops if tops else zisos
+
+    # collect temporary columns, made by geometrics() and _extract_ztops() methods
+    tmp_columns = [
+        col
+        for col in (ztopnames or []) + (zisonames or [])
+        if col.startswith("Q_") and col not in self.get_lognames()
+    ]
+
+    dataframe = (
+        pd.DataFrame(zlist, columns=ztopnames)
+        if tops
+        else pd.DataFrame(zlist, columns=zisonames)
+    )
+
+    return dataframe.drop(columns=tmp_columns, errors="ignore")
+
+
+def _extract_ztops(
+    self,
+    zonelist,
+    xcv,
+    ycv,
+    zcv,
+    zlog,
+    mdv,
+    incl,
+    tops=True,
+    incl_limit=80,
+    prefix="Top",
+    use_undef=False,
+):
+    """Extract a list of tops for a zone.
+
+    Args:
+        zonelist (list-like): The zonelog list numbers to apply; either
+            as a list, or a tuple; 2 entries forms a range [start, stop]
+        xcv (np): X Position numpy array
+        ycv (np): Y Position numpy array
+        zcv (np): Z Position numpy array
+        zlog (np): Zonelog array
+        mdv (np): MDepth log numpy array
+        incl (np): Inclination log numpy array
+        tops (bool): Compute tops or thickness (zone) points (default True)
+        incl_limit (float): Limitation of zone computation (angle, degrees)
+        use_undef (bool): If True, then transition from UNDEF is also
+            used.
+    """
+
+    # The wellpoints will be a list of tuples (one tuple per hit)
+    wpts = []
+    zlogname = self.zonelogname
+
+    if not tops and incl_limit is None:
+        incl_limit = 80
+
+    azi = -999.0  # tmp so far
+
+    if isinstance(zonelist, tuple):
+        if len(zonelist) != 2:
+            raise ValueError(
+                f"zonelist given as tuple must be of length 2, was {len(zonelist)}"
+            )
+        usezonerange = range(zonelist[0], zonelist[1] + 1)
+    elif isinstance(zonelist, list):
+        if len(zonelist) == 1:
+            raise ValueError(
+                f"zonelist given as list must contain two or more"
+                f" elements, had 1: {zonelist}"
+            )
+        usezonerange = zonelist
+    else:
+        raise TypeError(
+            f"zonelist must be either list (of two or more elements) or "
+            f"a tuple (with two elements representing start and stop), was"
+            f"{type(zonelist)}"
+        )
+
+    # check if increasing monotonic and with no jumps:
+    if not all(i + 1 == j for i, j in zip(usezonerange, usezonerange[1:])):
+        raise ValueError(
+            f"zonelist must be strictly increasing with increment of one,"
+            f" was {usezonerange}"
+        )
+
+    iundef = UNDEF_INT
+    iundeflimit = UNDEF_INT_LIMIT
+    pzone = iundef
+
+    if use_undef:
+        pzone = usezonerange[0] - 1
+
+    for ind, zone in np.ndenumerate(zlog):
+        ino = ind[0]  # since ind is a tuple...
+
+        if pzone != zone and pzone < iundeflimit and zone < iundeflimit:
+            logger.debug("Found break in zonation")
+            if pzone < zone:
+                logger.debug(
+                    "Found match, increasing zonation at %s < %s (MD %s)",
+                    pzone,
+                    zone,
+                    mdv[ino],
+                )
+                for kzv in range(pzone + 1, zone + 1):
+                    if kzv in usezonerange:
+                        zname = self.get_logrecord_codename(zlogname, kzv)
+                        zname = prefix + zname
+                        ztop = (
+                            xcv[ino],
+                            ycv[ino],
+                            zcv[ino],
+                            mdv[ino],
+                            incl[ino],
+                            azi,
+                            kzv,
+                            zname,
+                            self.xwellname,
+                        )
+                        wpts.append(ztop)
+            if pzone > zone and ino > 0:
+                logger.debug(
+                    "Found match, decreasing zonation at %s > %s (MD %s)",
+                    pzone,
+                    zone,
+                    mdv[ino - 1],
+                )
+                for kzv in range(pzone, zone, -1):
+                    if kzv in usezonerange:
+                        zname = self.get_logrecord_codename(zlogname, kzv)
+                        zname = prefix + zname
+                        ztop = (
+                            xcv[ino - 1],
+                            ycv[ino - 1],
+                            zcv[ino - 1],
+                            mdv[ino - 1],
+                            incl[ino - 1],
+                            azi,
+                            kzv,
+                            zname,
+                            self.xwellname,
+                        )
+                        wpts.append(ztop)
+        pzone = zone
+
+    wpts_names = [
+        self.xname,
+        self.yname,
+        self.zname,
+        self.mdlogname,
+        "Q_INCL",
+        "Q_AZI",
+        "Zone",
+        "TopName",
+        "WellName",
+    ]
+
+    if tops:
+        return wpts, wpts_names, None, None
+
+    # next get a MIDPOINT zthickness (DZ)
+    llen = len(wpts) - 1
+
+    zwpts_names = [
+        self.xname,
+        self.yname,
+        self.zname,
+        self.mdlogname + "_AVG",
+        "Q_MD1",
+        "Q_MD2",
+        "Q_INCL",
+        "Q_AZI",
+        "Zone",
+        "ZoneName",
+        "WellName",
+    ]
+
+    zwpts = []
+    for ino in range(llen):
+        i1v = ino
+        i2v = ino + 1
+        xx1, yy1, zz1, md1, incl1, _azi1, zk1, zn1, wn1 = wpts[i1v]
+        xx2, yy2, zz2, md2, incl2, _azi2, zk2, zn2, _wn2 = wpts[i2v]
+
+        # mid point
+        xx_avg = (xx1 + xx2) / 2
+        yy_avg = (yy1 + yy2) / 2
+        md_avg = (md1 + md2) / 2
+        incl_avg = (incl1 + incl2) / 2
+
+        azi_avg = -999.0  # to be fixed later
+
+        zzp = round(abs(zz2 - zz1), 4)
+
+        useok = False
+
+        if incl_avg < incl_limit:
+            useok = True
+
+        if useok and zk2 != zk1:
+            usezk = zk1
+            usezn = zn1
+            if zk1 > zk2:
+                usezk = zk2
+                usezn = zn2
+            usezn = usezn[len(prefix) :]
+
+            zzone = (
+                xx_avg,
+                yy_avg,
+                zzp,
+                md_avg,
+                md1,
+                md2,
+                incl_avg,
+                azi_avg,
+                usezk,
+                usezn,
+                wn1,
+            )
+            zwpts.append(zzone)
+
+    return wpts, wpts_names, zwpts, zwpts_names
+
+
+def get_fraction_per_zone(
+    self,
+    dlogname,
+    dvalues,
+    zonelist=None,
+    incl_limit=80,
+    count_limit=3,
+    zonelogname=None,
+):
+    """Fraction of e.g. a facies in a zone segment.
+
+        X_UTME       Y_UTMN    Z_TVDSS  Zonelog  Facies  M_INCL
+    464011.719  5931757.257  1663.1079      3.0     1.0    10.2
+    464011.751  5931757.271  1663.6084      3.0     1.0    10.3
+    464011.783  5931757.285  1664.1090      3.0     2.0    11.2
+    464011.815  5931757.299  1664.6097      3.0     2.0    11.4
+    464011.847  5931757.313  1665.1105      3.0     2.0    11.5
+    464011.879  5931757.326  1665.6114      3.0     2.0    12.0
+    464011.911  5931757.340  1666.1123      3.0     1.0    12.2
+    464011.943  5931757.354  1666.6134      3.0     1.0    13.4
+
+    Count fraction of one or more facies (dvalues list)
+    filtered on a zone, given that Inclination is below limit all over.
+    Since a zone can be repeated, it is important to split
+    into segments by POLY_ID. When fraction is determined, the
+    AVG X Y coord is applied.
+
+    If there are one or more occurences of undef for the dlogname
+    in that interval, no value shall be computed.
+
+    Args:
+        dlogname (str): Name of discrete log e.g. Facies
+        dvalues (list): List of codes to sum fraction upon
+        zonelist (list): List of zones to compute over
+        incl_limit (float): Skip if max inclination found > incl_limit
+        count_limit (int): Minimum number of samples required per segment
+
+    Returns:
+        A dataframe with relevant data...
+
+    """
+    logger.debug("The zonelist is %s", zonelist)
+    logger.debug("The dlogname is %s", dlogname)
+    logger.debug("The dvalues are %s", dvalues)
+
+    if zonelogname is not None:
+        usezonelogname = zonelogname
+        self.zonelogname = zonelogname
+    else:
+        usezonelogname = self.zonelogname
+
+    if usezonelogname is None:
+        raise RuntimeError("Stop, zonelogname is None")
+
+    self.make_zone_qual_log("_QFLAG")
+
+    if zonelist is None:
+        # need to declare as list; otherwise Py3 will get dict.keys
+        zonelist = list(self.get_logrecord(self.zonelogname).keys())
+
+    useinclname = "Q_INCL"
+    if "M_INCL" in self.get_dataframe(copy=False):
+        useinclname = "M_INCL"
+    else:
+        self.geometrics()
+
+    result = {}
+    result[self.xname] = []
+    result[self.yname] = []
+    result["DFRAC"] = []
+    result["Q_INCL"] = []
+    result["ZONE"] = []
+    result["WELLNAME"] = []
+    result[dlogname] = []
+
+    svalues = str(dvalues).rstrip("]").lstrip("[").replace(", ", "+")
+
+    xtralogs = [dlogname, useinclname, "_QFLAG"]
+    for izon in zonelist:
+        logger.debug("The zone number is %s", izon)
+        logger.debug("The extralogs are %s", xtralogs)
+
+        dfr = self.get_zone_interval(izon, extralogs=xtralogs)
+
+        if dfr is None:
+            continue
+
+        dfrx = dfr.groupby("POLY_ID")
+
+        for _polyid, dframe in dfrx:
+            qinclmax = dframe["Q_INCL"].max()
+            qinclavg = dframe["Q_INCL"].mean()
+            qflag = dframe["_QFLAG"].mean()
+            dseries = dframe[dlogname]
+            if qflag < 0.5 or qflag > 2.5:  # 1 or 2 is OK
+                logger.debug("Skipped due to zone %s", qflag)
+                continue
+            if qinclmax > incl_limit:
+                logger.debug("Skipped due to max inclination %s", qinclmax)
+                continue
+            if dseries.size < count_limit:  # interval too short for fraction
+                logger.debug("Skipped due to too few values %s", dseries.size)
+                continue
+            if dseries.max() > UNDEF_INT_LIMIT:
+                logger.debug("Skipped due to too missing/undef value(s)")
+                continue
+
+            xavg = dframe[self.xname].mean()
+            yavg = dframe[self.yname].mean()
+
+            dfrac = 0.0
+            for dval in dvalues:
+                if any(dseries.isin([dval])):
+                    dfrac += dseries.value_counts(normalize=True)[dval]
+
+            result[self.xname].append(xavg)
+            result[self.yname].append(yavg)
+            result["DFRAC"].append(dfrac)
+            result["Q_INCL"].append(qinclavg)
+            result["ZONE"].append(izon)
+            result["WELLNAME"].append(self.xwellname)
+            result[dlogname].append(svalues)
+
+    # make the dataframe and return it
+    if result[self.xname]:
+        return pd.DataFrame.from_dict(result)
+
+    self.delete_log("_QFLAG")
+
+    return None
+
+
+def get_surface_picks(self, surf):
+    """get Surface picks"""
+
+    dataframe = self.get_dataframe(copy=False)
+    xcor = dataframe[self.xname].values
+    ycor = dataframe[self.yname].values
+    zcor = dataframe[self.zname].values
+
+    if self.mdlogname:
+        mcor = dataframe[self.mdlogname].values
+    else:
+        mcor = np.zeros(xcor.size, dtype=np.float64) + UNDEF
+
+    nval, xres, yres, zres, mres, dres = _cxtgeo.well_surf_picks(
+        xcor,
+        ycor,
+        zcor,
+        mcor,
+        surf.ncol,
+        surf.nrow,
+        surf.xori,
+        surf.yori,
+        surf.xinc,
+        surf.yinc,
+        surf.yflip,
+        surf.rotation,
+        surf.npvalues1d,
+        xcor.size,
+        xcor.size,
+        xcor.size,
+        xcor.size,
+        xcor.size,
+    )
+
+    if nval > 0:
+        poi = Points()
+
+        mres[mres > UNDEF_LIMIT] = np.nan
+
+        res = {}
+        res[poi.xname] = xres[:nval]
+        res[poi.yname] = yres[:nval]
+        res[poi.zname] = zres[:nval]
+        if self.mdlogname:
+            res[self.mdlogname] = mres[:nval]
+        res["DIRECTION"] = dres[:nval]
+        res["WELLNAME"] = self.wellname
+
+        poi.set_dataframe(pd.DataFrame.from_dict(res))
+
+        return poi
+
+    return None
+
+    # return a xtgeo Poinst() object with points as dataframe, given that nval > 0

xtgeo/well/_wells_utils.py

@@ -0,0 +1,158 @@
+"""Utilities for Wells class"""
+
+import logging
+
+import numpy as np
+import pandas as pd
+import shapely.geometry as sg
+
+from xtgeo.common.xtgeo_dialog import XTGeoDialog, XTGShowProgress
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+xtg = XTGeoDialog()
+
+# self == Wells instance (plural wells)
+
+
+def wellintersections(
+    self,
+    wfilter=None,
+    showprogress=False,
+):
+    """Get intersections between wells, return as dataframe table.
+
+    This routine is using "shapely" functions!
+
+    Some actions are done in order to filter away the part of the trajectories
+    that are paralell.
+
+    """
+
+    xpoints = []
+
+    # make a dict if nocrossings
+    nox = {}
+
+    wlen = len(self.wells)
+
+    progress = XTGShowProgress(wlen, show=showprogress, leadtext="progress: ", skip=5)
+
+    for iwell, well in enumerate(self.wells):
+        progress.flush(iwell)
+
+        logger.debug("Work with %s", well.name)
+        try:
+            well.geometrics()
+        except ValueError:
+            logger.debug("Skip %s (cannot compute geometrics)", well.name)
+            continue
+
+        welldfr = well.get_dataframe()
+
+        xcor = welldfr[well.xname].values
+        ycor = welldfr[well.yname].values
+        mcor = welldfr[well.mdlogname].values
+        logger.debug("The mdlogname property is: %s", well.mdlogname)
+
+        if xcor.size < 2:
+            continue
+
+        thisline1 = sg.LineString(np.stack([xcor, ycor], axis=1))
+        thisline2 = sg.LineString(np.stack([xcor, ycor, mcor], axis=1))
+
+        nox[well.name] = []
+        # loop over other wells
+        for other in self.wells:
+            if other.name == well.name:
+                continue  # same well
+
+            if not well.may_overlap(other):
+                nox[well.name].append(other.name)
+                continue  # a quick check; no chance for overlap
+
+            logger.debug("Consider crossing with %s ...", other.name)
+
+            # try to be smart to skip entries that earlier have beenn tested
+            # for crossing. If other does not cross well, then well does not
+            # cross other...
+            if other.name in nox and well.name in nox[other.name]:
+                continue
+
+            # truncate away the paralell part on a copy
+            owell = other.copy()
+
+            # wfilter = None
+            if wfilter is not None and "parallel" in wfilter:
+                xtol = wfilter["parallel"].get("xtol")
+                ytol = wfilter["parallel"].get("ytol")
+                ztol = wfilter["parallel"].get("ztol")
+                itol = wfilter["parallel"].get("itol")
+                atol = wfilter["parallel"].get("atol")
+                owell.truncate_parallel_path(
+                    well, xtol=xtol, ytol=ytol, ztol=ztol, itol=itol, atol=atol
+                )
+
+            other_dframe = owell.get_dataframe()
+            xcorc = other_dframe[well.xname].values
+            ycorc = other_dframe[well.yname].values
+            zcorc = other_dframe[well.zname].values
+
+            if xcorc.size < 2:
+                continue
+
+            otherline = sg.LineString(np.stack([xcorc, ycorc, zcorc], axis=1))
+
+            if not thisline1.crosses(otherline):
+                nox[well.name].append(other.name)
+                continue
+
+            ixx = thisline1.intersection(otherline)
+
+            if ixx.is_empty:
+                nox[well.name].append(other.name)
+                continue
+
+            # need this trick to get mdepth
+            other2 = sg.LineString(np.stack([xcorc, ycorc], axis=1))
+            ixx2 = thisline2.intersection(other2)
+
+            logger.debug("==> Intersects with %s", other.name)
+
+            if isinstance(ixx, sg.Point):
+                xcor, ycor, zcor = ixx.coords[0]
+                _x, _y, mcor = ixx2.coords[0]
+                xpoints.append([well.name, mcor, other.name, xcor, ycor, zcor])
+
+            elif isinstance(ixx, sg.MultiPoint):
+                pxx2 = list(ixx2)
+                for ino, pxx in enumerate(list(ixx)):
+                    xcor, ycor, zcor = pxx.coords[0]
+                    _x, _y, mcor = pxx2[ino].coords[0]
+                    xpoints.append([well.name, mcor, other.name, xcor, ycor, zcor])
+
+            elif isinstance(ixx, sg.GeometryCollection):
+                gxx2 = list(ixx2)
+                for ino, gxx in enumerate(list(ixx)):
+                    if isinstance(gxx, sg.Point):
+                        xcor, ycor, zcor = gxx.coords[0]
+                        _x, _y, mcor = gxx2[ino].coords[0]
+                        xpoints.append([well.name, mcor, other.name, xcor, ycor, zcor])
+
+    dfr = pd.DataFrame(
+        xpoints,
+        columns=[
+            "WELL",
+            "MDEPTH",
+            "CWELL",
+            self._wells[0].xname,
+            self._wells[0].yname,
+            self._wells[0].zname,
+        ],
+    )
+
+    progress.finished()
+
+    logger.debug("All intersections found!")
+    return dfr