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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.51.0
+Version: 0.53.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,33 @@ 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`.
 
+### Torque and drag
+
+The hook load and torque the drill string should take at each bit depth, by
+the soft-string model of Johancsik et al.: pick-up, slack-off and rotating
+off bottom for the declared friction factors and a fan of others (the
+broomstick), the torque rotating off bottom. Against them, the rig's own
+hook loads and torque from the drilling record, read by the rig states -
+tripping out and in, rotating off bottom - and the friction factors that fit
+them, cased and open hole apart. Volve 15/9-F-10 with an example string is
+the worked example. The **Torque & drag** tab, `gea torque-drag`,
+`gea help torque-drag`.
+
+### 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.53.0}/README.md

@@ -609,6 +609,33 @@ 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`.
 
+### Torque and drag
+
+The hook load and torque the drill string should take at each bit depth, by
+the soft-string model of Johancsik et al.: pick-up, slack-off and rotating
+off bottom for the declared friction factors and a fan of others (the
+broomstick), the torque rotating off bottom. Against them, the rig's own
+hook loads and torque from the drilling record, read by the rig states -
+tripping out and in, rotating off bottom - and the friction factors that fit
+them, cased and open hole apart. Volve 15/9-F-10 with an example string is
+the worked example. The **Torque & drag** tab, `gea torque-drag`,
+`gea help torque-drag`.
+
+### 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.53.0}/gea/__init__.py

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

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

@@ -622,6 +622,36 @@ def main(argv=None) -> int:
     p_pl.add_argument("--actor", type=str, default="cli")
     p_pl.add_argument("--json", action="store_true")
 
+    p_td = sub.add_parser("torque-drag", help="the hook load and torque the string should take at each bit depth (soft-string model), the broomstick, and the friction factors that fit the rig's own trips")
+    p_td.add_argument("--workspace", type=str, default=None)
+    p_td.add_argument("--well", type=str, default=None)
+    p_td.add_argument("--example", action="store_true", help="the worked example (Volve 15/9-F-10 with an example string)")
+    p_td.add_argument("--string", type=str, default=None, help="sections from the bit up: 'BHA:300:6.75:95; drill pipe::5:22.6:6.625' (what:length_ft:od_in:lb_ft[:contact_od_in])")
+    p_td.add_argument("--mud", type=str, default=None, help="mud density, ppg")
+    p_td.add_argument("--mu-cased", type=str, default=None)
+    p_td.add_argument("--mu-open", type=str, default=None)
+    p_td.add_argument("--block", type=str, default=None, help="the travelling block's weight, klbf (estimated from the record when not declared)")
+    p_td.add_argument("--source", type=str, default="", help="where the string and its figures came from")
+    p_td.add_argument("--write", action="store_true")
+    p_td.add_argument("--actor", type=str, default="cli")
+    p_td.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 +2486,72 @@ 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 == "torque-drag":
+        import json as _json
+        from . import torque_drag as _TND
+        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"
+            if ws is not None and any(v is not None for v in (a.string, a.mud, a.mu_cased, a.mu_open, a.block)):
+                if not a.well:
+                    raise ValueError("--well is needed")
+                c_ = _TND.set_well(ws, a.actor, a.well, a.source, _TND.parse_string(a.string) if a.string else None, a.mud, a.mu_cased, a.mu_open, a.block)
+                print(f"{a.well}: " + "; ".join(f"{x['what']} {('to surface' if x['length_ft'] is None else format(x['length_ft'], ',.0f') + ' ft')}" for x in (c_.get('string') or []))
+                      + f"; mud {c_['mud_ppg']:g} ppg, mu cased {c_['mu_cased']:g}, open {c_['mu_open']:g}")
+                return 0
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _TND.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 = _TND.page(ws, scene, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"torque-drag: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _TND.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.53.0}/gea/acceptance_tests.py

@@ -11717,6 +11717,354 @@ 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 section_cv_torque_drag(tmp: str) -> None:
+    """Section CV - torque and drag: the soft-string model against closed forms (a vertical string, a straight inclined
+    one pulled and rotated, the capstan over a bend in the vertical plane and in azimuth); a drilling record made by the
+    model with known friction factors, read back by the rig states and fitted to them; the worked example; the API, the
+    CLI, the report, the dossier, the tab and the help."""
+    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 rig_state as RS
+    from . import torque_drag as TND
+    from . import well3d as W
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "torquedrag"); d.mkdir()
+
+    # -- CV1 the model against closed forms ------------------------------------------------------------------------------
+    md = _np.linspace(0.0, 10000.0, 101); n = len(md)
+    bf = TND.buoyancy(10.0)
+    Fv, _ = TND.soft_string(md, _np.zeros(n), _np.zeros(n), _np.full(n - 1, 20.0 * bf), _np.full(n - 1, 3.3125), _np.full(n - 1, 0.3), "out")
+    s60, c60 = _m.sin(_m.radians(60)), _m.cos(_m.radians(60))
+    Fo, _ = TND.soft_string(md, _np.full(n, 60.0), _np.zeros(n), _np.full(n - 1, 20.0), _np.full(n - 1, 3.0), _np.full(n - 1, 0.3), "out")
+    Fi, _ = TND.soft_string(md, _np.full(n, 60.0), _np.zeros(n), _np.full(n - 1, 20.0), _np.full(n - 1, 3.0), _np.full(n - 1, 0.3), "in")
+    Fr, Mr = TND.soft_string(md, _np.full(n, 60.0), _np.zeros(n), _np.full(n - 1, 20.0), _np.full(n - 1, 3.0), _np.full(n - 1, 0.3), "rotate")
+    N_ = 9001
+    mc = _np.linspace(0.0, 1000.0, N_)
+    Fc, _ = TND.soft_string(mc, _np.linspace(0.0, 90.0, N_), _np.zeros(N_), _np.zeros(N_ - 1), _np.full(N_ - 1, 3.0), _np.full(N_ - 1, 0.3), "out", 10000.0)
+    Fa, _ = TND.soft_string(mc, _np.full(N_, 90.0), _np.linspace(0.0, 90.0, N_), _np.zeros(N_ - 1), _np.full(N_ - 1, 3.0), _np.full(N_ - 1, 0.3), "out", 10000.0)
+    cap = 10000.0 * _m.exp(0.3 * _m.pi / 2)
+    refused = 0
+    for bad in ([], [{"what": "x", "length_ft": None, "od_in": 5, "weight_lb_ft": 20}, {"what": "y", "length_ft": None, "od_in": 5, "weight_lb_ft": 20}],
+                [{"what": "x", "length_ft": 100, "od_in": 0.5, "weight_lb_ft": 20}], [{"what": "x", "length_ft": 100, "od_in": 5, "weight_lb_ft": 900}],
+                [{"what": "x", "length_ft": 100, "od_in": 6, "weight_lb_ft": 20, "contact_od_in": 5}]):
+        try:
+            TND.check_string(bad)
+        except ValueError:
+            refused += 1
+    c1 = {
+        "vertical": abs(Fv[0] - 20.0 * bf * 10000.0) < 1e-6 and abs(bf - (1 - 10.0 / 65.5)) < 1e-12,
+        "inclined": abs(Fo[0] - 200000.0 * (c60 + 0.3 * s60)) < 1e-6 and abs(Fi[0] - 200000.0 * (c60 - 0.3 * s60)) < 1e-6 and abs(Fr[0] - 200000.0 * c60) < 1e-6
+                    and abs(Mr[0] - 0.3 * 200000.0 * s60 * 3.0 / 12.0) < 1e-6,
+        "capstan": abs(Fc[0] / cap - 1) < 5e-5 and abs(Fa[0] / cap - 1) < 5e-5,
+        "string": refused == 5 and TND.parse_string("BHA:300:6.75:95; dp::5:22.6:6.625")[1]["length_ft"] is None,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CV1 the soft-string model against closed forms: a vertical string weighs its buoyed weight; a straight 60-degree string "
+       "pulled, run and rotated gives W(cos + mu sin), W(cos - mu sin), W cos and the torque mu W sin r exactly; a weightless string "
+       "over a 90-degree bend, in the vertical plane or in azimuth, comes to the capstan's e^(mu theta) as the elements shrink; a "
+       "string without sections, with two open-ended, or with a diameter, weight or contact diameter out of range refused"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CV2 a record made by the model, read back ---------------------------------------------------------------------------
+    f = TND.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wid = ws.add_well_file(f["record"], display="TD-1", actor="tester")["id"]
+    ws.set_well(wid, surface={"lat": 31.42, "lon": -104.10, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+    no_survey = TND.page(ws, "workspace", wid)["detail"]
+    W.attach_trajectory(ws, wid, "s.csv", Path(f["survey"]).read_bytes(), "tester", "true", "ft", None, None, None, "test survey")
+    no_string = TND.page(ws, "workspace", wid)["detail"]
+    RS.set_casing(ws, "tester", wid, "9-5/8", 4000, "tally (test)")
+    TND.set_well(ws, "tester", wid, "BHA report (test)", f["string"], 10.0, 0.25, 0.30)
+    r = TND.page(ws, "workspace", wid)["result"]
+    fi = r["fits"]
+    m_ = r["measured"]
+    c2 = {
+        "needs": "survey" in no_survey and "string" in no_string,
+        "measured": len(m_["out"]["depth_ft"]) >= 70 and len(m_["in"]["depth_ft"]) >= 70 and len(m_["rotate"]["depth_ft"]) == 9 and abs(r["block_klbf"] - 40.0) < 0.5 and m_["block_estimated"],
+        "open": all(abs(fi[k]["mu"] - 0.24) <= 0.02 for k in ("out:open", "in:open", "torque:open")),
+        "cased": all(abs(fi[k]["mu"] - 0.18) <= 0.02 for k in ("out:cased", "in:cased", "torque:cased")),
+        "weights": abs(r["string_air_klbf"] - (300 * 95.0 + (r["td_ft"] - 300) * 22.6) / 1000.0) < 0.05 and r["shoe_ft"] == 4000.0,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CV2 a drilling record made by the model - a trip out and in stand by stand, the string rotated off bottom every 900 ft, "
+       "friction 0.18 cased above a 4,000 ft shoe and 0.24 open, a 40 klbf block, noise - read back by the rig states: the block "
+       "estimated to half a klbf, the pick-up, slack-off and torque each fitting 0.18 cased and 0.24 open to within 0.02; a well "
+       "without a survey or a string says what it needs"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CV3 the worked example -----------------------------------------------------------------------------------------------
+    ex = TND.example()
+    de = ex["declared"]
+    c3 = {
+        "example": ex["well"] == "15/9-F-10" and abs(ex["td_ft"] - 5300.07 / 0.3048) < 5.0 and ex["max_inc_deg"] > 80
+                   and all(de["out"][i] >= de["rotate"][i] >= de["in"][i] for i in range(len(de["depth_ft"])))
+                   and de["torque"][-1] > de["torque"][len(de["torque"]) // 2] > 0 and "not from Volve" in ex["config"]["source"],
+        "fan": sorted(ex["fan"]) == ["0.1", "0.2", "0.3", "0.4", "0.5"] and ex["fan"]["0.5"]["out"][-1] > ex["fan"]["0.1"]["out"][-1] and ex["fan"]["0.5"]["in"][-1] < ex["fan"]["0.1"]["in"][-1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CV3 the worked example, Volve 15/9-F-10's survey to its 5,300 m TD with a string declared for the example: pick-up above "
+       "rotating above slack-off at every depth, the torque growing with depth, the broomstick fanning out with the friction factor"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CV4 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/torque-drag?well=" + wid)
+        s_ve, ve = call(V, "GET", "/api/torque-drag?scene=example")
+        s_vs, _ = call(V, "POST", "/api/torque-drag/settings", {"well_id": wid, "mud_ppg": 11, "source": "x"})
+        s_os, os_ = call(O, "POST", "/api/torque-drag/settings", {"well_id": wid, "mud_ppg": "11", "string": "BHA:300:6.75:95:6.75; dp::5:22.6:6.625", "source": "mud report (test)"})
+        s_bs, _ = call(O, "POST", "/api/torque-drag/settings", {"well_id": wid, "string": "BHA:300", "source": "x"})
+        s_bm, _ = call(O, "POST", "/api/torque-drag/settings", {"well_id": wid, "mu_open": 0.9, "source": "x"})
+        s_ns, _ = call(O, "POST", "/api/torque-drag/settings", {"well_id": wid, "mud_ppg": 12})
+        s_vw, _ = call(V, "POST", "/api/torque-drag/write", {"well_id": wid})
+        s_ow, ow = call(O, "POST", "/api/torque-drag/write", {"well_id": wid})
+    finally:
+        svc.stop()
+    cli_x = _sp.run([sys.executable, "-m", "gea", "torque-drag", "--example"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_s = _sp.run([sys.executable, "-m", "gea", "torque-drag", "--workspace", wsp, "--well", wid, "--mu-open", "0.26", "--source", "offset well (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "torque-drag", "--workspace", wsp, "--well", wid], 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"]["fits"] and s_ve == 200 and ve["result"]["well"] == "15/9-F-10" and s_vs == 403 and s_os == 200 and os_["mud_ppg"] == 11.0
+               and len(os_["string"]) == 2 and s_bs == 400 and s_bm == 400 and s_ns == 400 and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("TND-"),
+        "cli": cli_x.returncode == 0 and "15/9-F-10" in cli_x.stdout and cli_s.returncode == 0 and "open 0.26" in cli_s.stdout and cli_t.returncode == 0
+               and "fits mu" in cli_t.stdout and "mud 11 ppg" in cli_t.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "wells", wid, "torque_drag.pdf")) and "torque_drag.declare" in audit and "report.torque_drag" in audit,
+        "dossier": "declarations/drillstring/torque_drag.json" in names and f"results/torque_drag/{wid}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.torquedrag", "['#/torquedrag', 'Torque & drag']", "/api/torque-drag/settings", "tdChart")),
+        "help": not H.check("torque-drag") and H.VIEW_TOPIC.get("torquedrag") == "torque-drag",
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CV4 on the API (anyone reads a well's model and the worked example; only an operator declares the string, the mud and the "
+       "friction factors - a section without its figures, a friction factor of 0.9 or a change without its source refused - or "
+       "writes the report), the CLI, the report as PDF, a signed dossier carrying the string and the model, 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 +12174,8 @@ def main() -> int:
         section_cr_collision(tmp)
         section_cs_plan_and_tools(tmp)
         section_ct_frac_hits(tmp)
+        section_cu_pore_pressure(tmp)
+        section_cv_torque_drag(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

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

@@ -277,7 +277,8 @@ 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'),
+                ('drillstring', 'torque_drag.json')):
         p = os.path.join(ws.path, *rel)
         if os.path.isfile(p):
             out_list.append((p, 'declarations/' + '/'.join(rel)))
@@ -299,8 +300,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 torque and
+    drag, 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 +339,28 @@ 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 torque_drag as TND
+        declared = (TND._load(ws).get('wells') or {})
+        for wid in wells:
+            if wid in declared:
+                r = TND.page(ws, 'workspace', wid).get('result')
+                if r:
+                    out.append((f'results/torque_drag/{wid}.json', json.dumps({k: v for k, v in r.items() if k != 'fan'}, indent=1, sort_keys=True,
+                                                                              default=str).encode('utf-8')))
+    except Exception as e:
+        out.append(('results/torque_drag_not_run.txt', f'the torque-and-drag model 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):