gea-program 0.51.0__tar.gz → 0.52.0__tar.gz

{gea_program-0.51.0 → gea_program-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.51.0
+Version: 0.52.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -648,6 +648,21 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Pore pressure
+
+The mud-weight window from a well's logs or its drilling record. The
+overburden from the density log (or Gardner's density from the sonic); the
+shale's normal compaction trend over an interval the operator declares
+normally pressured; the pore pressure by Eaton's method from the sonic, the
+deep resistivity or the corrected d-exponent computed from the drilling
+record; the fracture gradient by Eaton's relation and the Hubbert-Willis
+minimum - all as equivalent mud weights against true vertical depth, with
+formation tests, kicks and leak-off tests beside them, the Eaton exponent
+that fits the tests, and the mud weight used flagged where it falls outside
+the window. The Dutch offshore well L07-01 (NLOG open data) is the worked
+example. The **Pore pressure** tab, `gea pore-pressure`,
+`gea help pore-pressure`.
+
 ### Frac hits
 
 What each fracturing stage did to the pressure in the wells around it. A

{gea_program-0.51.0 → gea_program-0.52.0}/README.md

@@ -609,6 +609,21 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Pore pressure
+
+The mud-weight window from a well's logs or its drilling record. The
+overburden from the density log (or Gardner's density from the sonic); the
+shale's normal compaction trend over an interval the operator declares
+normally pressured; the pore pressure by Eaton's method from the sonic, the
+deep resistivity or the corrected d-exponent computed from the drilling
+record; the fracture gradient by Eaton's relation and the Hubbert-Willis
+minimum - all as equivalent mud weights against true vertical depth, with
+formation tests, kicks and leak-off tests beside them, the Eaton exponent
+that fits the tests, and the mud weight used flagged where it falls outside
+the window. The Dutch offshore well L07-01 (NLOG open data) is the worked
+example. The **Pore pressure** tab, `gea pore-pressure`,
+`gea help pore-pressure`.
+
 ### Frac hits
 
 What each fracturing stage did to the pressure in the wells around it. A

{gea_program-0.51.0 → gea_program-0.52.0}/gea/__init__.py

@@ -123,7 +123,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.51.0"
+__version__ = "0.52.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.51.0 → gea_program-0.52.0}/gea/__main__.py

@@ -622,6 +622,22 @@ def main(argv=None) -> int:
     p_pl.add_argument("--actor", type=str, default="cli")
     p_pl.add_argument("--json", action="store_true")
 
+    p_pp = sub.add_parser("pore-pressure", help="the mud-weight window: overburden, pore pressure by Eaton from the sonic, the resistivity or the d-exponent, and the fracture gradient")
+    p_pp.add_argument("--workspace", type=str, default=None)
+    p_pp.add_argument("--well", type=str, default=None)
+    p_pp.add_argument("--example", action="store_true", help="the worked example (L07-01, public data)")
+    p_pp.add_argument("--indicator", type=str, default=None, help="auto, sonic, resistivity or dexponent")
+    for k_, h_ in (("exponent", "Eaton's exponent"), ("nct-top", "top of the normally pressured interval, m TVD"), ("nct-bottom", "its bottom, m TVD"),
+                   ("gr-cutoff", "the shale cut-off, gAPI"), ("normal-gradient", "the normal pore gradient, psi/ft"), ("poisson", "Poisson's ratio"),
+                   ("density-above", "the mean density above the logs, g/cm3"), ("water-depth", "the water depth, m"), ("air-gap", "the air gap, m"),
+                   ("bit", "the bit size for the d-exponent, in")):
+        p_pp.add_argument("--" + k_, type=str, default=None, help=h_)
+    p_pp.add_argument("--measure", type=str, default=None, help="add a measurement DEPTH_M,VALUE[,psi|ppg[,pore|kick|lot|fit[,tvd|md]]]")
+    p_pp.add_argument("--source", type=str, default="", help="where the values came from")
+    p_pp.add_argument("--write", action="store_true", help="write the report")
+    p_pp.add_argument("--actor", type=str, default="cli")
+    p_pp.add_argument("--json", action="store_true")
+
     p_fh = sub.add_parser("frac-hits", help="what each fracturing stage did to the pressure in the wells around it: none, poroelastic, mixed or a frac hit, the first response and the volume pumped by then")
     p_fh.add_argument("--workspace", type=str, required=True)
     p_fh.add_argument("--well", type=str, default=None, help="the treatment well (with --stages or --remove) or the monitored well (with --channel)")
@@ -2456,6 +2472,43 @@ def main(argv=None) -> int:
             raise SystemExit(f"collision: {e.args[0] if e.args else e}")
         print(_json.dumps({k: v for k, v in r.items()}, default=str) if a.json else _CO.text(r))
         return 0
+    elif a.cmd == "pore-pressure":
+        import json as _json
+        from . import pore_pressure as _PPF
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace) if a.workspace else None
+            scene = "example" if (a.example or ws is None) else "workspace"
+            keys = {"exponent": a.exponent, "nct_top_m": a.nct_top, "nct_bottom_m": a.nct_bottom, "gr_cutoff": a.gr_cutoff,
+                    "normal_gradient_psi_ft": a.normal_gradient, "poisson": a.poisson, "density_above_gcc": a.density_above,
+                    "water_depth_m": a.water_depth, "air_gap_m": a.air_gap, "bit_in": a.bit, "indicator": a.indicator}
+            if ws is not None and (any(v is not None for v in keys.values()) or a.measure):
+                if not a.well:
+                    raise ValueError("--well is needed")
+                if a.measure:
+                    p_ = [x.strip() for x in a.measure.split(",")]
+                    r_ = _PPF.add_measurement(ws, a.actor, a.well, p_[0], p_[1], p_[2] if len(p_) > 2 else "psi", p_[3] if len(p_) > 3 else "pore",
+                                              p_[4] if len(p_) > 4 else "tvd", a.source)
+                    print(f"measurement kept for {a.well}: {r_['kind']} {r_['value']:g} {r_['unit']} at {r_['depth_m']:g} m {r_['depth_kind'].upper()}")
+                    return 0
+                c_ = _PPF.set_well(ws, a.actor, a.well, a.source, **{k: v for k, v in keys.items() if v is not None})
+                print(f"{a.well}: {c_['indicator']}, exponent {c_['exponent'] or 'Eaton'}, trend {c_['nct_top_m']} to {c_['nct_bottom_m']} m, normal {c_['normal_gradient_psi_ft']:g} psi/ft, Poisson {c_['poisson']:g}")
+                return 0
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _PPF.write_report(ws, __version__, a.well, a.actor, scene)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _PPF.page(ws, scene, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"pore-pressure: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _PPF.text(r))
+        return 0
     elif a.cmd == "frac-hits":
         import json as _json
         from . import frac_hits as _FH

{gea_program-0.51.0 → gea_program-0.52.0}/gea/acceptance_tests.py

@@ -11717,6 +11717,194 @@ def section_ct_frac_hits(tmp: str) -> None:
        + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
 
 
+def section_cu_pore_pressure(tmp: str) -> None:
+    """Section CU - pore pressure and fracture gradient: the arithmetic (overburden, Gardner, Eaton, the d-exponent and
+    its correction, Eaton's and Hubbert-Willis's fracture gradients) by hand; a depth log and a drilling record built so
+    Eaton's method must return a known overpressure, read back by the sonic, the resistivity and the corrected
+    d-exponent; measurements and the fitted exponent; the worked example; the API, the CLI, the report, the dossier,
+    the tab and the help."""
+    import gzip
+    import hashlib as _hl
+    import http.cookiejar
+    import math as _m
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile as _zf
+    import numpy as _np
+    from . import __version__ as _ver
+    from . import dossier as DZ
+    from . import helplib as H
+    from . import pore_pressure as PPF
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "porepressure"); d.mkdir()
+
+    # -- CU1 the arithmetic by hand ------------------------------------------------------------------------------------------
+    dd = float(PPF.dexponent([30.0], [100.0], [20000.0], 8.5)[0])
+    d_hand = _m.log10(30.0 / 6000.0) / _m.log10(12.0 * 20000.0 / 8.5e6)
+    dc_ = float(PPF.dc([d_hand], 8.95, [10.0])[0])
+    ob = PPF.overburden_psi(_np.array([1000.0, 2000.0]), _np.array([2.3, 2.3]), 0.0, 0.0, 1.03, 2.3)
+    ob_sea = PPF.overburden_psi(_np.array([137.0, 1137.0]), _np.array([2.0, 2.0]), 100.0, 37.0, 1.03, 2.0)
+    psi_hand = lambda rho, h: rho * 1000.0 * 9.80665 * h / 6894.757293168
+    S_, Ph_ = 10000.0, 4650.0
+    pp_s = float(PPF.eaton(S_, Ph_, 120.0, 100.0, 3.0, -1))           # sonic slower than its trend: overpressure
+    pp_r = float(PPF.eaton(S_, Ph_, 0.8, 1.0, 1.2, 1))                # resistivity below its trend: overpressure
+    c1 = {
+        "dexp": abs(dd - d_hand) < 1e-12 and abs(d_hand - 1.48529) < 1e-4 and abs(dc_ - d_hand * 0.895) < 1e-12 and _np.isnan(PPF.dexponent([0.0], [100.0], [20000.0], 8.5)[0]),
+        "overburden": abs(ob[0] - psi_hand(2.3, 1000.0)) < 1e-6 and abs(ob[1] - psi_hand(2.3, 2000.0)) < 1e-6
+                      and abs(ob_sea[0] - psi_hand(1.03, 100.0)) < 1e-6 and abs(ob_sea[1] - psi_hand(1.03, 100.0) - psi_hand(2.0, 1000.0)) < 1e-6,
+        "gardner": abs(float(PPF.gardner(_np.array([100.0]))[0]) - 0.23 * 10000.0 ** 0.25) < 1e-12,
+        "eaton": abs(pp_s - (S_ - (S_ - Ph_) * (100.0 / 120.0) ** 3)) < 1e-9 and pp_s > Ph_ and abs(pp_r - (S_ - (S_ - Ph_) * 0.8 ** 1.2)) < 1e-9
+                 and abs(float(PPF.eaton(S_, Ph_, 100.0, 100.0, 3.0, -1)) - Ph_) < 1e-9,
+        "fracture": abs(float(PPF.eaton_fg(S_, 6000.0, 0.25)) - float(PPF.hubbert_willis(S_, 6000.0))) < 1e-9
+                    and abs(float(PPF.eaton_fg(S_, 6000.0, 0.4)) - (0.4 / 0.6 * 4000.0 + 6000.0)) < 1e-9,
+        "ppg": abs(float(PPF.ppg(5200.0, 10000.0 * 0.3048)) - 10.0) < 1e-9,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CU1 the arithmetic by hand: Jorden and Shirley's d-exponent (1.4853 for 30 ft/h, 100 rpm, 20 klbf on an 8-1/2 in bit) and "
+       "Rehm and McClendon's correction; the overburden of rock alone and of sea then rock below an air gap; Gardner's density; "
+       "Eaton's ratio for the sonic and the resistivity, returning hydrostatic on the trend; Eaton's fracture gradient equal to "
+       "Hubbert-Willis's at a Poisson's ratio of 0.25; an equivalent mud weight"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CU2 the labelled log and drilling record --------------------------------------------------------------------------
+    f = PPF.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wl = ws.add_well_file(f["las"], display="LOG-1", actor="tester")["id"]
+    we = ws.add_well_file(f["edr"], display="EDR-1", actor="tester")["id"]
+
+    def err_of(wid):
+        x = PPF.page(ws, "workspace", wid)["result"]
+        c = x["curves"]
+        z = _np.array(c["tvd_m"], float)
+        pp = _np.array([_np.nan if v is None else v for v in c["pp_psi"]], float)
+        Pt = PPF.truth(z)[2]
+        away = (_np.abs(z - 2200.0) > 10.0) & (_np.abs(z - 2600.0) > 10.0) & _np.isfinite(pp)
+        return x, float(_np.max(_np.abs(pp[away] - Pt[away]) / Pt[away])), int(away.sum())
+    PPF.set_well(ws, "tester", wl, "labelled log (test)", indicator="sonic", nct_top_m=600, nct_bottom_m=2100, smooth_m=5, density_above_gcc=2.3)
+    xs, es, ns = err_of(wl)
+    PPF.set_well(ws, "tester", wl, "labelled log (test)", indicator="resistivity")
+    xr, er, nr = err_of(wl)
+    no_bit = PPF.page(ws, "workspace", we)["detail"]
+    PPF.set_well(ws, "tester", we, "labelled record (test)", bit_in=8.5, nct_top_m=1050, nct_bottom_m=2100, smooth_m=6, density_above_gcc=2.3)
+    xd, ed, nd = err_of(we)
+    c2 = {
+        "sonic": es < 0.002 and ns > 300 and abs(xs["trend"]["a"] - 2.25) < 1e-4 and abs(xs["trend"]["b_per_m"] + 1.2e-4) < 1e-8
+                 and xs["overpressure_from_tvd_m"] is not None and abs(xs["overpressure_from_tvd_m"] - 2200.0) <= 5.0 and abs(xs["overburden_td_psi"] - float(PPF.truth(_np.array([3500.0]))[0][0])) < 1.0,
+        "resistivity": er < 0.002 and nr > 300 and xr["indicator"] == "resistivity" and abs(xr["trend"]["b_per_m"] - 1.5e-4) < 1e-8,
+        "dexponent": "bit size" in no_bit and ed < 0.002 and nd > 300 and xd["indicator"] == "dexponent" and "Mud Weight In" in xd["how"] and abs(xd["trend"]["b_per_m"] - 1.0e-4) < 2e-6,
+        "mud_flag": any(fl["what"] == "the mud weight below the pore pressure" and abs(fl["from_tvd_m"] - 2200.0) < 6 and abs(fl["to_tvd_m"] - 2600.0) < 6 for fl in xd["flags"]),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CU2 a depth log and a drilling record built so that Eaton's method must find a pore pressure 40 % of the way from "
+       "hydrostatic to the overburden between 2,200 and 2,600 m: read back by the sonic, the resistivity and the corrected "
+       "d-exponent to within 0.2 % away from the zone's edges, the trends recovered as built, the overburden to the psi; the "
+       "d-exponent refused without a bit size; the 9.5 ppg mud flagged below the pore pressure across the zone"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CU3 measurements, the fitted exponent, refusals and the worked example ----------------------------------------------
+    PPF.set_well(ws, "tester", wl, "labelled log (test)", indicator="sonic")
+    pt = float(PPF.truth(_np.array([2400.0]))[2][0])
+    PPF.add_measurement(ws, "tester", wl, 2400.0, round(pt, 1), "psi", "pore", "tvd", "MDT (test)")
+    PPF.add_measurement(ws, "tester", wl, 1500.0, 16.2, "ppg", "lot", "tvd", "LOT (test)")
+    xm = PPF.page(ws, "workspace", wl)["result"]
+    refused = 0
+    for kw in ({"poisson": 0.6}, {"normal_gradient_psi_ft": 0.3}, {"nct_top_m": 2000, "nct_bottom_m": 1000}, {"indicator": "magic"}, {"exponent": 2.0}):
+        try:
+            PPF.set_well(ws, "tester", wl, "" if "exponent" in kw else "x", **kw)
+        except ValueError:
+            refused += 1
+    for args in ((wl, -5, 100), (wl, 1000, 100, "bar"), (wl, 1000, 100, "psi", "dst"), (wl, 1000, 100, "psi", "pore", "tvd", "")):
+        try:
+            PPF.add_measurement(ws, "tester", args[0], args[1], args[2], *(args[3:5] or ()), **({"depth_kind": args[5], "source": args[6]} if len(args) > 6 else {"source": "s"}))
+        except ValueError:
+            refused += 1
+    ex = PPF.example()
+    raw = gzip.open(pkg / "reference" / "l0701_sonic_gr.las.gz").read()
+    prov = json.loads((pkg / "reference" / "l0701_sonic_gr.provenance.json").read_text(encoding="utf-8"))
+    c3 = {
+        "measured": len(xm["measured"]) == 2 and abs(xm["measured"][0]["computed_psi"] - pt) < 0.005 * pt and xm["fit_exponent"] is not None and abs(xm["fit_exponent"] - 3.0) < 0.06
+                    and abs(xm["measured"][1]["psi"] - 16.2 * 0.052 * 1500.0 / 0.3048) < 0.1 and xm["measured"][1]["kind"] == "lot",
+        "refused": refused == 9,
+        "example": ex["indicator"] == "sonic" and ex["channel"] == "DT" and ex["trend"]["points"] > 5000 and 18.0 < ex["overburden_td_ppg"] < 21.0
+                   and "Gardner from the sonic" in ex["density_from"] and "density log" in ex["density_from"] and ex["max_pp_ppg"] is not None and "NLOG" in ex["attribution"],
+        "provenance": _hl.sha256(raw).hexdigest() == prov["sha256_uncompressed"] and _hl.sha256((pkg / "reference" / "l0701_sonic_gr.las.gz").read_bytes()).hexdigest() == prov["sha256"],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CU3 a formation test drawn beside the curve it confirms (to half a percent) and the Eaton exponent fitted to it (3); a "
+       "leak-off test in ppg turned to psi at its depth; a Poisson's ratio, a normal gradient, a trend interval or an indicator "
+       "out of range, a value without its source, and a measurement without a depth, a unit, a kind or a source refused; the "
+       "worked example L07-01 read from its sonic with the overburden from its density log and Gardner's, the file as hashed"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CU4 the API, the CLI, the report, the dossier, the tab and the help -------------------------------------------------
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vg, vg = call(V, "GET", "/api/pore-pressure?well=" + wl)
+        s_ve, ve = call(V, "GET", "/api/pore-pressure?scene=example")
+        s_vs, _ = call(V, "POST", "/api/pore-pressure/settings", {"well_id": wl, "poisson": 0.3, "source": "x"})
+        s_os, os_ = call(O, "POST", "/api/pore-pressure/settings", {"well_id": wl, "poisson": "0.3", "source": "frac gradient study (test)"})
+        s_ob, _ = call(O, "POST", "/api/pore-pressure/settings", {"well_id": wl, "poisson": 0.7, "source": "x"})
+        s_om, _ = call(O, "POST", "/api/pore-pressure/measure", {"well_id": wl, "depth_m": 3000, "value": 9.0, "unit": "ppg", "kind": "kick", "source": "kick (test)"})
+        s_bm, _ = call(O, "POST", "/api/pore-pressure/measure", {"well_id": wl, "depth_m": 3000, "value": 9.0, "unit": "ppg", "kind": "kick", "source": ""})
+        s_ur, _ = call(O, "POST", "/api/pore-pressure/unmeasure", {"well_id": wl, "index": 2})
+        s_u2, _ = call(O, "POST", "/api/pore-pressure/unmeasure", {"well_id": wl, "index": 9})
+        s_vw, _ = call(V, "POST", "/api/pore-pressure/write", {"well_id": wl})
+        s_ow, ow = call(O, "POST", "/api/pore-pressure/write", {"well_id": wl})
+    finally:
+        svc.stop()
+    cli_x = _sp.run([sys.executable, "-m", "gea", "pore-pressure", "--example"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_s = _sp.run([sys.executable, "-m", "gea", "pore-pressure", "--workspace", wsp, "--well", wl, "--gr-cutoff", "90", "--source", "shale cut-off (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_m = _sp.run([sys.executable, "-m", "gea", "pore-pressure", "--workspace", wsp, "--well", wl, "--measure", "2500,13.0,ppg,pore,tvd", "--source", "RFT (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "pore-pressure", "--workspace", wsp, "--well", wl], capture_output=True, text=True, cwd=str(pkg.parent))
+    dz = DZ.build(ws, "tester", _ver, None)
+    names = _zf.ZipFile(Path(ws.reports_dir, dz["path"])).namelist()
+    audit = Path(ws.audit_path).read_text(encoding="utf-8")
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "api": s_vg == 200 and vg["result"]["indicator"] == "sonic" and s_ve == 200 and ve["result"]["well"] == "L07-01" and s_vs == 403 and s_os == 200 and os_["poisson"] == 0.3
+               and s_ob == 400 and s_om == 200 and s_bm == 400 and s_ur == 200 and s_u2 == 404 and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("PPF-"),
+        "cli": cli_x.returncode == 0 and "L07-01" in cli_x.stdout and cli_s.returncode == 0 and cli_m.returncode == 0 and "pore 13 ppg at 2500 m TVD" in cli_m.stdout
+               and cli_t.returncode == 0 and "gamma ray >= 90" in cli_t.stdout and "the exponent that fits" in cli_t.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "wells", wl, "pore_pressure.pdf"))
+                  and all(x in audit for x in ("pore_pressure.settings", "pore_pressure.measurement", "pore_pressure.measurement_removed", "report.pore_pressure")),
+        "dossier": "declarations/geomech/pore_pressure.json" in names and f"results/pore_pressure/{wl}.json" in names and f"results/pore_pressure/{we}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.porepressure", "['#/porepressure', 'Pore pressure']", "/api/pore-pressure/settings", "ppDepthPlot", "ppTrendPlot")),
+        "help": not H.check("pore-pressure") and H.VIEW_TOPIC.get("porepressure") == "pore-pressure",
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CU4 on the API (anyone reads a well's window and the worked example; only an operator declares how a well is read - a "
+       "Poisson's ratio of 0.7 refused - adds or removes a measurement - one without its source refused - or writes the report), "
+       "the CLI (the example, a cut-off, a measurement, the well), the report as PDF, a signed dossier carrying the declarations "
+       "and each declared well's window, the tab and the help"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -11826,6 +12014,7 @@ def main() -> int:
         section_cr_collision(tmp)
         section_cs_plan_and_tools(tmp)
         section_ct_frac_hits(tmp)
+        section_cu_pore_pressure(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.51.0 → gea_program-0.52.0}/gea/dossier.py

@@ -277,7 +277,7 @@ def _gather(ws, well_id: Optional[str]) -> Dict[str, List[tuple]]:
                 ('seismicity', 'catalogs.json'), ('seismicity', 'settings.json'), ('config', 'fleet.json'), ('workspace.json',),
                 ('economics', 'invoices', 'terms.json'), ('economics', 'invoices', 'files.json'), ('drillstring', 'rig_time.json'),
                 ('drillstring', 'casing.json'), ('wellpath', 'collision.json'), ('wellpath', 'survey_program.json'),
-                ('completion', 'frac', 'stages.json'), ('completion', 'frac', 'settings.json')):
+                ('completion', 'frac', 'stages.json'), ('completion', 'frac', 'settings.json'), ('geomech', 'pore_pressure.json')):
         p = os.path.join(ws.path, *rel)
         if os.path.isfile(p):
             out_list.append((p, 'declarations/' + '/'.join(rel)))
@@ -299,8 +299,8 @@ def _gather(ws, well_id: Optional[str]) -> Dict[str, List[tuple]]:
 
 def _results(ws, well_id: Optional[str]) -> List[tuple]:
     """The invoice cross-check of each well with invoices or reports attached, the rig time of each well with a drilling
-    record, the collision check, each surveyed well against its plan and the frac-hit check, as JSON computed when the
-    dossier is signed (a check that cannot run is left out, and says why)."""
+    record, the collision check, each surveyed well against its plan, each declared well's pore pressure and the
+    frac-hit check, as JSON computed when the dossier is signed (a check that cannot run is left out, and says why)."""
     out = []
     wells = [well_id] if well_id else [w['id'] for w in ws.wells()]
     try:
@@ -338,6 +338,17 @@ def _results(ws, well_id: Optional[str]) -> List[tuple]:
                                                                                  indent=1, sort_keys=True, default=str).encode('utf-8')))
     except Exception as e:
         out.append(('results/collision_not_run.txt', f'the collision check did not run: {type(e).__name__}: {e}\n'.encode('utf-8')))
+    try:
+        from . import pore_pressure as PPF
+        declared = (PPF._load(ws).get('wells') or {})
+        for wid in wells:
+            if wid in declared:
+                r = PPF.page(ws, 'workspace', wid).get('result')
+                if r:
+                    out.append((f'results/pore_pressure/{wid}.json', json.dumps({k: v for k, v in r.items() if k != 'points'}, indent=1, sort_keys=True,
+                                                                                default=str).encode('utf-8')))
+    except Exception as e:
+        out.append(('results/pore_pressure_not_run.txt', f'the pore-pressure reading did not run: {type(e).__name__}: {e}\n'.encode('utf-8')))
     try:
         from . import frac_hits as FH
         if FH.stages(ws):

gea_program-0.52.0/gea/help/pore-pressure.md

@@ -0,0 +1,17 @@
+# Pore pressure
+
+> The mud-weight window from a well's logs or its drilling record: the overburden; the pore pressure by Eaton's method from the sonic, the deep resistivity or the corrected d-exponent against the shale's normal compaction trend; the fracture gradient by Eaton's relation and the Hubbert-Willis minimum; measured pressures and the mud weight used beside them. The Dutch offshore well L07-01 is the worked example.
+
+**The command**: the **Pore pressure** tab: the pressures as equivalent mud weights against true vertical depth, with the hydrostatic, the overburden, the fracture gradients, the measurements and the mud; beside it the indicator against depth on a log scale, the shale points, the trend and the interval it was fitted over; how the well is read and its measurements (the operator role); **Write the report**. From a terminal: `gea pore-pressure --workspace C:\site --well W` prints it; `--example` the worked example; `--indicator sonic --nct-top 600 --nct-bottom 2100 --gr-cutoff 75 --normal-gradient 0.465 --poisson 0.25 --density-above 2.1 --water-depth 0 --air-gap 0 --bit 8.5 --source "drilling program"` declares how it is read; `--measure 2400,5337,psi,pore,tvd --source "MDT station 14"` adds a measurement (`lot` or `fit` for a leak-off or formation-integrity test, `ppg` for an equivalent weight, `md` for a measured depth); `--write` writes the report.
+
+**What it reads**: a well whose record is a depth log (LAS) with a sonic (DT, AC), a deep resistivity (RDEP, ILD, RT) and a gamma ray, a bulk density where there is one; or a drilling record with hole depth, rate of penetration, rotary speed and weight on bit, from which the d-exponent is computed on the drilling samples (the median every 3 m of hole), corrected by the record's mud density when it has one - the bit size must be declared. True vertical depth comes from the well's survey, else the recorder's interpolated TVD, else the well is taken as vertical.
+
+**How it is computed**: the overburden integrates the density - the sea below the air gap, then the rock: the density log, else Gardner's density from the sonic (0.23 V^0.25), else the declared mean density above the first value. The normal compaction trend is a straight line in the logarithm of the indicator against TVD, fitted to the shale (gamma ray at or above the cut-off; the 60th percentile when none is declared) over the interval the operator declares normally pressured. Eaton's ratio gives the pore pressure: Pp = S - (S - Ph) (X/Xn)^n, sonic exponent 3.0, resistivity and d-exponent 1.2. A step read below 90 % of hydrostatic is rock faster than the shale trend and is left blank. The fracture gradient is Eaton's F = nu/(1 - nu) (S - Pp) + Pp with the declared Poisson's ratio, beside the Hubbert-Willis minimum (S - Pp)/3 + Pp. Overpressure is read where the pore pressure stays half a ppg over hydrostatic for 50 m. With formation tests declared, the Eaton exponent that best fits them is given; with a mud weight in the record, a stretch where it is below the pore pressure or above the fracture gradient is flagged.
+
+**What it writes**: how each well is read and its measurements in `geomech\pore_pressure.json` (audit lines `pore_pressure.settings`, `pore_pressure.measurement`, `pore_pressure.measurement_removed`), the audit line `report.pore_pressure`, and the reports `reports\wells\<well>\pore_pressure.*` (or `reports\pore_pressure_example.*`; PDF, HTML, markdown, JSON).
+
+**The number to check**: the overburden at TD against the density log integrated by hand; a formation test's pressure against the curve at its depth; the trend's slope against the shale points on the right-hand plot.
+
+**What this page will not call a measurement**: the pore pressure where nothing was measured - it is computed from a log against its trend, and the trend is the operator's choice of a normally pressured interval. The fracture gradient - a relation with a declared Poisson's ratio, not a leak-off test. The pressure in sand and carbonate - the method reads shale.
+
+**Sources**: Eaton, "The equation for geopressure prediction from well logs", SPE-5544 (1975); Eaton, "Fracture gradient prediction and its application in oilfield operations", JPT 21(10) (1969); Gardner, Gardner and Gregory, Geophysics 39(6) (1974); Jorden and Shirley, SPE-1407 (1966); Rehm and McClendon, SPE-3601 (1971); Hubbert and Willis, Trans. AIME 210 (1957). The worked example: well L07-01, NLOG open data.

{gea_program-0.51.0 → gea_program-0.52.0}/gea/helplib.py

@@ -57,6 +57,7 @@ INDEX: List[tuple] = [
     ('collision', 'Well collision checks', "every well scanned against every other, planned wells along their plans: the closest approach and the ISCWSA separation factor, the travelling cylinder, each well's position uncertainty by its survey program's ISCWSA / OWSG tool models, the field by WMM2025; the Volve template as the worked example"),
     ('plan', 'Plan vs actual', "a well against its directional plan: the distance high or low and right or left at each survey against the survey's own uncertainty, the bit projected, the one arc back to the plan and its toolface; each well's survey program by tool model"),
     ('frac-hits', 'Frac hits', "what each fracturing stage did to the pressure in the wells around it - none, poroelastic, mixed or a frac hit - the first response and the fluid pumped by then, the distance and the earthquakes beside each stage"),
+    ('pore-pressure', 'Pore pressure', "the mud-weight window from a well's logs or its drilling record: the overburden, the pore pressure by Eaton from the sonic, the resistivity or the d-exponent against a normal compaction trend, the fracture gradient, against measured pressures and the mud used; L07-01 as the worked example"),
     ('rig-time', 'Rig time', "what the rig did each second of the drilling record - drilling, the slips, tripping, circulating - its connections timed weight to weight, its trips by speed, and the time lost against the pad's own best quarter"),
     ('invoice-check', 'The invoice cross-check', "the drilling contractor's daywork invoice, day by day, against the daily drilling reports and the drilling record at the contract's terms: hours, rates, standby, the repair allowance, depth and footage, with the dollars each difference puts in question"),
     ('economics', 'Economics', 'each well\'s days, footage and cost by the operator\'s own declared rates, against the EIA oil and gas spot prices while it was drilled, and any series the site imports'),
@@ -89,7 +90,7 @@ REQUIRED_LINES = ('**The command**', '**What it writes**', '**The number to chec
 VIEW_TOPIC: Dict[str, str] = {
     'home': 'start', 'wells': 'data-in', 'well': 'drift', 'live': 'patches', 'patch': 'patches', 'files': 'files', 'alarms': 'alarms',
     'approvals': 'well-tests', 'config': 'site', 'reports': 'drift', 'verify': 'start', 'survey': 'data-in', 'jobs': 'site',
-    'admin': 'site', 'prefs': 'site', 'search': 'start', 'welcome': 'start', 'seismic': 'seismic', 'seismic_station': 'seismic', 'track': 'seismic', 'sar': 'seismic', 'sites': 'sites', 'setup': 'setup', 'map': 'map', '3d': 'well3d', 'simulation': 'simulation', 'drillstring': 'drillstring', 'completion': 'penetrator', 'opseis': 'opseis', 'economics': 'economics', 'invoices': 'invoice-check', 'rigtime': 'rig-time', 'collision': 'collision', 'plan': 'plan', 'frac': 'frac-hits', 'control': 'control-room', 'wall': 'control-room', 'audit': 'audit-update', 'tools': 'tools', 'catalog': 'catalog',
+    'admin': 'site', 'prefs': 'site', 'search': 'start', 'welcome': 'start', 'seismic': 'seismic', 'seismic_station': 'seismic', 'track': 'seismic', 'sar': 'seismic', 'sites': 'sites', 'setup': 'setup', 'map': 'map', '3d': 'well3d', 'simulation': 'simulation', 'drillstring': 'drillstring', 'completion': 'penetrator', 'opseis': 'opseis', 'economics': 'economics', 'invoices': 'invoice-check', 'rigtime': 'rig-time', 'collision': 'collision', 'plan': 'plan', 'frac': 'frac-hits', 'porepressure': 'pore-pressure', 'control': 'control-room', 'wall': 'control-room', 'audit': 'audit-update', 'tools': 'tools', 'catalog': 'catalog',
 }