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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.50.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,35 @@ 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
+treatment well's stage table (from the frac company's post-job report, CSV
+or Excel) is read against every well with a pressure gauge in its record:
+the pressure's departure from its own trend while the stage pumps and after
+it stops, the first response and the fluid pumped by then, and the type -
+no response, poroelastic (the rock squeezed, falling at the stop), mixed
+(a hydraulic connection, holding or rising after it) or a frac hit (the
+stage's fluid reaching the well). With surveys, the distance from each
+stage to the monitored well; with an earthquake catalogue, the earthquakes
+during each stage. A frac hit is an alert. The **Frac hits** tab,
+`gea frac-hits`, `gea help frac-hits`.
+
 ### Plan vs actual and the survey tools
 
 Each well against its directional plan: at every survey station, how far

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

@@ -609,6 +609,35 @@ 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
+treatment well's stage table (from the frac company's post-job report, CSV
+or Excel) is read against every well with a pressure gauge in its record:
+the pressure's departure from its own trend while the stage pumps and after
+it stops, the first response and the fluid pumped by then, and the type -
+no response, poroelastic (the rock squeezed, falling at the stop), mixed
+(a hydraulic connection, holding or rising after it) or a frac hit (the
+stage's fluid reaching the well). With surveys, the distance from each
+stage to the monitored well; with an earthquake catalogue, the earthquakes
+during each stage. A frac hit is an alert. The **Frac hits** tab,
+`gea frac-hits`, `gea help frac-hits`.
+
 ### Plan vs actual and the survey tools
 
 Each well against its directional plan: at every survey station, how far

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

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

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

@@ -622,6 +622,38 @@ 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)")
+    p_fh.add_argument("--stages", type=str, default=None, help="attach FILE as the well's stage table (CSV or Excel)")
+    p_fh.add_argument("--depth-unit", type=str, default="ft")
+    p_fh.add_argument("--utc-offset", type=str, default=None, help="the stage clock's hours from UTC (for the earthquake count)")
+    p_fh.add_argument("--remove", action="store_true", help="take the well's stage table off it")
+    p_fh.add_argument("--channel", type=str, default=None, help="with --well: the monitored pressure channel ('' for the first in psi)")
+    p_fh.add_argument("--hit-psi", type=str, default=None, help="a frac hit from this many psi")
+    p_fh.add_argument("--min-psi", type=str, default=None, help="the smallest response, psi")
+    p_fh.add_argument("--k-sigma", type=str, default=None, help="the response threshold in multiples of the trend's noise")
+    p_fh.add_argument("--source", type=str, default="", help="where the stage table or the rule came from")
+    p_fh.add_argument("--write", action="store_true", help="write the report")
+    p_fh.add_argument("--actor", type=str, default="cli")
+    p_fh.add_argument("--json", action="store_true")
+
     p_rt = sub.add_parser("rig-time", help="what the rig did each second of the drilling record - drilling, connections, trips, the slips - and the time lost against the pad's own best")
     p_rt.add_argument("--workspace", type=str, required=True)
     p_rt.add_argument("--well", type=str, default=None, help="with --write: one well's report (without it, the pad's)")
@@ -2440,6 +2472,80 @@ 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
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+            if a.stages or a.remove or a.channel is not None:
+                if not a.well:
+                    raise ValueError("--well is needed")
+            if a.stages:
+                with open(a.stages, "rb") as f_:
+                    r_ = _FH.attach_stages(ws, a.well, os.path.basename(a.stages), f_.read(), a.actor, a.source, a.depth_unit, a.utc_offset)
+                print(f"stage table attached to {a.well}: {r_['stages']} stages, {r_['first'][:16]} to {r_['last'][:16]}")
+                return 0
+            if a.remove:
+                _FH.remove_stages(ws, a.well, a.actor)
+                print(f"stage table removed from {a.well}")
+                return 0
+            if a.channel is not None or a.hit_psi is not None or a.min_psi is not None or a.k_sigma is not None:
+                s_ = _FH.set_settings(ws, a.actor, a.source, (a.well, a.channel) if a.channel is not None else None,
+                                      hit_psi=a.hit_psi, min_psi=a.min_psi, k_sigma=a.k_sigma)
+                print(f"rule: frac hit from {s_['hit_psi']:g} psi, threshold {s_['k_sigma']:g} x noise and at least {s_['min_psi']:g} psi; monitors: "
+                      + (", ".join(f"{k} {v['channel']}" for k, v in s_['monitors'].items()) or "the first pressure channel of each well"))
+                return 0
+            if a.write:
+                r_ = _FH.write_report(ws, __version__, a.actor)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _FH.page(ws)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"frac-hits: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _FH.text(r))
+        return 0
     elif a.cmd == "plan":
         import json as _json
         from . import wellplan as _PL

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

@@ -11537,6 +11537,374 @@ def section_cs_plan_and_tools(tmp: str) -> None:
        + (f" [failed: {', '.join(failed5)}]" if failed5 else ""))
 
 
+def section_ct_frac_hits(tmp: str) -> None:
+    """Section CT - frac hits: each fracturing stage read on the pressure of the wells around it - none, poroelastic,
+    mixed or a frac hit - with the first response and the fluid pumped by then, checked on a labelled record built to
+    answer each way; the stage table read from CSV or Excel by its column names and refused when wrong; the distance
+    from each stage to the monitored well and the earthquakes during it; the alert, raised once; the API, the CLI, the
+    report, the dossier, the tab and the help."""
+    import base64 as _b64
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile as _zf
+    from datetime import datetime, timedelta
+    from . import __version__ as _ver
+    from . import alerts as AL
+    from . import dossier as DZ
+    from . import frac_hits as FH
+    from . import helplib as H
+    from . import op_seismicity as OS
+    from . import well3d as W
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "frac"); d.mkdir()
+
+    # -- CT1 the labelled record ---------------------------------------------------------------------------------------------
+    f = FH.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    tw = ws.add_well_file(f["gauge"], display="Treat 1H", actor="tester")["id"]
+    mw = ws.add_well_file(f["gauge"], display="Monitor 2H", actor="tester")["id"]
+    FH.attach_stages(ws, tw, "frac_stages.csv", Path(f["stages"]).read_bytes(), "tester", "post-job report (test)", "ft", -5)
+    r = FH.analyse(ws)
+    got = {s_["stage"]: s_["responses"][0] for s_ in r["stages"] if s_["responses"]}
+    hit = got.get("4", {})
+    t_, p_, t0_ = FH._series(ws, mw, "P_gauge_psi")
+    st4 = next(s_ for s_ in r["stages"] if s_["stage"] == "4")
+    a4 = (datetime.fromisoformat(st4["start"]) - t0_).total_seconds(); b4 = a4 + 7200.0
+    strict = FH.respond(t_, p_, a4, b4, {**FH.DEFAULTS, "hit_psi": 1000.0})
+    c1 = {
+        "types": {k: v.get("type") for k, v in got.items()} == f["expected"] and r["count"] == {"NONE": 2, "POROELASTIC": 2, "MIXED": 1, "FRAC HIT": 1},
+        "first": abs(hit.get("first_response_s", 0) - 1200.0) <= 30.0 and abs(hit.get("vfr_bbl", 0) - 9400.0 * hit.get("first_response_s", 0) / 7200.0) < 0.1
+                 and abs(got["2"]["first_response_s"] - 2640.0) <= 60.0,
+        "after": got["2"]["after_stop"] == "fell" and got["3"]["after_stop"] == "rose" and hit.get("after_stop") == "held" and abs(hit.get("peak_psi", 0) - 900.0) < 5.0,
+        "noise": all(0.4 < v["noise_psi"] < 0.7 and v["threshold_psi"] == 5.0 for v in got.values()) and all(v["first_response_s"] is None for k, v in got.items() if k in ("1", "6")),
+        "rule": strict["type"] == "MIXED" and abs(got["5"]["peak_psi"] - 8.0) < 1.5,
+        "own_well": all(x["monitor_id"] != tw for s_ in r["stages"] for x in s_["responses"]),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CT1 a labelled gauge record built so its six stages answer each way: nothing, poroelastic (25 psi, falling at the stop), "
+       "mixed (60 psi, rising after it), a frac hit (900 psi, holding), poroelastic (8 psi), nothing - each read as built, with the "
+       "first response twenty minutes into the hit and the fluid pumped by then in proportion; the trend's noise taken as the "
+       "half-psi it is; a declared 1,000 psi rule reading the same stage as mixed; a well never its own monitor"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CT2 the stage table --------------------------------------------------------------------------------------------------
+    alt = "Stage No,Pump Start,Pump End,Top MD (m),Bottom MD (m),Slurry Volume (gal),Total Proppant\n1,08/03/2026 07:00,08/03/2026 09:00,4000,4060,420000,400000\n"
+    a_ = FH.read_stages(alt.encode())
+    XR.write_simple(str(d / "st.xlsx"), [["Stage", "Start", "End"], [1, datetime(2026, 8, 3, 7), datetime(2026, 8, 3, 9)], [2, datetime(2026, 8, 3, 12), datetime(2026, 8, 3, 14)]])
+    x_ = FH.read_stages((d / "st.xlsx").read_bytes())
+    refused = 0
+    for bad in ("Stage,Start\n1,2026-08-03 07:00\n", "Stage,Start,End\n1,2026-08-03 09:00,2026-08-03 07:00\n",
+                "Stage,Start,End\n1,2026-08-03 07:00,2026-08-03 09:00\n1,2026-08-03 10:00,2026-08-03 11:00\n", "Stage,Start,End\n1,yesterday,today\n"):
+        try:
+            FH.read_stages(bad.encode())
+        except ValueError:
+            refused += 1
+    try:
+        FH.attach_stages(ws, tw, "s.csv", alt.encode(), "tester", " ")
+        no_src = False
+    except ValueError:
+        no_src = True
+    c2 = {
+        "synonyms": a_[0]["top_md_m"] == 4000.0 and a_[0]["bottom_md_m"] == 4060.0 and abs(a_[0]["volume_bbl"] - 10000.0) < 1e-6 and a_[0]["proppant_lb"] == 400000.0
+                    and a_[0]["start"] == "2026-08-03T07:00:00",
+        "excel": [s_["stage"] for s_ in x_] == ["1", "2"] and x_[1]["end"] == "2026-08-03T14:00:00",
+        "feet": abs(st4["top_md_m"] - 14000 * 0.3048) < 1e-6,
+        "refused": refused == 4 and no_src,
+        "channel": FH.pressure_channel(ws, mw) == ("P_gauge_psi", "psi"),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CT2 the stage table read by its column names in either wording, with its units (metres, gallons), from CSV or Excel; a table "
+       "without an end column, a stage ending before it starts, a stage listed twice or a time that is not one refused, and a table "
+       "without its source; the monitored channel found by its unit"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CT3 the distance, the earthquakes and the alert ---------------------------------------------------------------------
+    for wid, dlat in ((tw, 0.0), (mw, 0.003)):
+        ws.set_well(wid, surface={"lat": 31.42 + dlat, "lon": -104.10, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+        sv = "MD (ft),Inc (deg),Azi (deg)\n" + "\n".join(f"{m_},{0.0 if m_ <= 9000 else min(90.0, (m_ - 9000) * 0.09)},90" for m_ in range(0, 16001, 100)) + "\n"
+        W.attach_trajectory(ws, wid, "s.csv", sv.encode(), "tester", "true", "ft", None, None, None, "MWD report (test)")
+    qtime = datetime.fromisoformat(st4["start"]) + timedelta(hours=5, minutes=30)          # 30 min into stage 4, in UTC (the stage clock is UTC-5)
+    cat = ("#EventID|Time|Latitude|Longitude|Depth/km|Author|Catalog|Contributor|ContributorID|MagType|Magnitude|MagAuthor|EventLocationName\n"
+           f"tx2026a|{qtime.isoformat()}|31.43|-104.05|5.0|TexNet|TX|TexNet|a|ML|2.1|TexNet|test\n"
+           f"tx2026b|{(qtime + timedelta(days=3)).isoformat()}|31.43|-104.05|5.0|TexNet|TX|TexNet|b|ML|1.8|TexNet|test\n")
+    OS.attach_catalog(ws, "tester", "cat.txt", cat.encode(), "2026-08-01", "2026-08-10", 1.0, 31.42, -104.10, 20.0, "TexNet (test)")
+    r3 = FH.analyse(ws)
+    q = {s_["stage"]: s_["earthquakes"] for s_ in r3["stages"]}
+    dist = [s_["responses"][0].get("distance_m") for s_ in r3["stages"] if s_["responses"]]
+    raised1 = AL.check_conditions(ws, None, force=True)
+    raised2 = AL.check_conditions(ws, None, force=True)
+    fh1 = [e for e in raised1 if e["event"] == "frac.hit"]
+    c3 = {
+        "distance": all(x is not None and 300.0 < x < 360.0 for x in dist),
+        "quakes": [len(q[k]) for k in sorted(q)] == [0, 0, 0, 1, 0, 0] and q["4"][0]["event_id"] == "tx2026a",
+        "alert": len(fh1) == 1 and fh1[0]["stage"] == "4" and fh1[0]["monitor"] == "Monitor 2H" and not [e for e in raised2 if e["event"] == "frac.hit"]
+                 and "frac.hit" in AL.EVENTS,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CT3 with both wells surveyed, each stage's mid-point a third of a kilometre from the monitored lateral as built; with a "
+       "catalogue and the stage clock five hours behind UTC, the one earthquake inside stage 4's window counted beside it and the "
+       "one three days later not; the frac hit raised as an alert once, not again"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CT4 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())
+    xb = _b64.b64encode((d / "st.xlsx").read_bytes()).decode()
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vg, vg = call(V, "GET", "/api/frac-hits")
+        s_va, _ = call(V, "POST", "/api/frac-hits/stages", {"well_id": mw, "filename": "st.xlsx", "content_b64": xb, "source": "x"})
+        s_oa, oa = call(O, "POST", "/api/frac-hits/stages", {"well_id": mw, "filename": "st.xlsx", "content_b64": xb, "source": "plan (test)"})
+        s_bo, _ = call(O, "POST", "/api/frac-hits/stages", {"well_id": mw, "filename": "b.csv", "content": "Stage,Start\n1,2026-08-03\n", "source": "x"})
+        s_ns, _ = call(O, "POST", "/api/frac-hits/settings", {"hit_psi": 500})
+        s_rs, rs = call(O, "POST", "/api/frac-hits/settings", {"hit_psi": 500, "source": "frac plan (test)"})
+        s_bc, _ = call(O, "POST", "/api/frac-hits/settings", {"monitor_id": "nowhere", "channel": "P"})
+        s_rm, _ = call(O, "POST", "/api/frac-hits/remove", {"well_id": mw})
+        s_r2, _ = call(O, "POST", "/api/frac-hits/remove", {"well_id": mw})
+        s_vw, _ = call(V, "POST", "/api/frac-hits/write", {})
+        s_ow, ow = call(O, "POST", "/api/frac-hits/write", {})
+        s_al, alj = call(V, "GET", "/api/alerts")
+    finally:
+        svc.stop()
+    cli_t = _sp.run([sys.executable, "-m", "gea", "frac-hits", "--workspace", wsp], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_r = _sp.run([sys.executable, "-m", "gea", "frac-hits", "--workspace", wsp, "--hit-psi", "250", "--source", "URTeC 2020-3129 (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_w = _sp.run([sys.executable, "-m", "gea", "frac-hits", "--workspace", wsp, "--write"], 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["count"]["FRAC HIT"] == 1 and len(vg["stages"]) == 6 and s_va == 403 and s_oa == 200 and oa["stages"] == 2 and s_bo == 400
+               and s_ns == 400 and s_rs == 200 and rs["hit_psi"] == 500.0 and s_bc == 404 and s_rm == 200 and s_r2 == 404 and s_vw == 403 and s_ow == 200
+               and ow["report_id"].startswith("FDI-") and s_al == 200 and "frac.hit" in alj["events"],
+        "cli": cli_t.returncode == 0 and "FRAC HIT 1" in cli_t.stdout and "stage 4" in cli_t.stdout and cli_r.returncode == 0 and "frac hit from 250 psi" in cli_r.stdout
+               and cli_w.returncode == 0 and "frac_hits" in cli_w.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "frac_hits.pdf")) and all(x in audit for x in ("frac.stages", "frac.stages_removed", "frac.settings", "report.frac_hits")),
+        "dossier": f"declarations/completion/frac/{tw}/frac_stages.csv" in names and "declarations/completion/frac/stages.json" in names and "results/frac_hits.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.frac", "['#/frac', 'Frac hits']", "/api/frac-hits/stages", "fhTrace", "'frac.hit': 'Frac hit'")),
+        "help": not H.check("frac-hits") and H.VIEW_TOPIC.get("frac") == "frac-hits" and "frac.hit" in (pkg / "help" / "alerts.md").read_text(encoding="utf-8"),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CT4 on the API (anyone reads the stages and their responses; only an operator attaches a stage table - an Excel one - or a "
+       "rule with its source, names a monitored channel, takes a table off or writes the report; the new alert listed), the CLI, "
+       "the report as PDF, a signed dossier carrying the stage tables and the check, the tab and the help"
+       + (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:
@@ -11645,6 +12013,8 @@ def main() -> int:
         section_cq_tied_together(tmp)
         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: