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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.52.0
+Version: 0.54.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,29 @@ 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`.
 
+### Decline curves
+
+Each well's monthly production fitted by Arps's curves - the modified
+hyperbolic, turned exponential at a terminal decline - forecast month by
+month to its economic limit and valued: the estimated ultimate recovery,
+and the net cash flow discounted at the declared rate, at the SEC 12-month
+average of the first-of-month WTI and Henry Hub prices (shipped from the
+EIA) or a declared price, with the net revenue interest, severance tax and
+operating cost declared. A forecast is not a reserves report, and the page
+says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
+
+### 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

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

@@ -609,6 +609,29 @@ 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`.
 
+### Decline curves
+
+Each well's monthly production fitted by Arps's curves - the modified
+hyperbolic, turned exponential at a terminal decline - forecast month by
+month to its economic limit and valued: the estimated ultimate recovery,
+and the net cash flow discounted at the declared rate, at the SEC 12-month
+average of the first-of-month WTI and Henry Hub prices (shipped from the
+EIA) or a declared price, with the net revenue interest, severance tax and
+operating cost declared. A forecast is not a reserves report, and the page
+says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
+
+### 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

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

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

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

@@ -622,6 +622,35 @@ def main(argv=None) -> int:
     p_pl.add_argument("--actor", type=str, default="cli")
     p_pl.add_argument("--json", action="store_true")
 
+    p_dc = sub.add_parser("decline", help="each well's monthly production fitted by Arps's curves, forecast to its economic limit and valued at the SEC 12-month price or a declared one")
+    p_dc.add_argument("--workspace", type=str, required=True)
+    p_dc.add_argument("--well", type=str, default=None)
+    p_dc.add_argument("--attach", type=str, default=None, help="attach FILE as the well's monthly production (CSV or Excel)")
+    p_dc.add_argument("--remove", action="store_true")
+    for k_, h_ in (("terminal-decline", "the terminal decline, effective annual (0.08 = 8 %%)"), ("b-max", "the largest b fitted"), ("oil-price", "USD/bbl"),
+                   ("gas-price", "USD/MMBtu"), ("price-basis", "sec or flat"), ("nri", "the net revenue interest"), ("severance", "the severance tax (0.046 = 4.6 %%)"),
+                   ("opex", "the operating cost, USD a month"), ("discount", "the discount rate (0.10)"), ("start", "fit from this month (YYYY-MM)"),
+                   ("as-of", "value as of this date (YYYY-MM-DD)")):
+        p_dc.add_argument("--" + k_, type=str, default=None, help=h_)
+    p_dc.add_argument("--source", type=str, default="", help="where the production or the terms came from")
+    p_dc.add_argument("--write", action="store_true")
+    p_dc.add_argument("--actor", type=str, default="cli")
+    p_dc.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)
@@ -2472,6 +2501,71 @@ 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 == "decline":
+        import json as _json
+        from . import decline as _DCA
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+            terms = {"terminal_decline": a.terminal_decline, "b_max": a.b_max, "oil_price": a.oil_price, "gas_price": a.gas_price, "price_basis": a.price_basis,
+                     "nri": a.nri, "severance": a.severance, "opex_month": a.opex, "discount": a.discount, "start": a.start}
+            if (a.attach or a.remove or any(v is not None for v in terms.values()) or a.write) and not a.well:
+                raise ValueError("--well is needed")
+            if a.attach:
+                with open(a.attach, "rb") as f_:
+                    r_ = _DCA.attach(ws, a.well, os.path.basename(a.attach), f_.read(), a.actor, a.source)
+                print(f"production attached to {a.well}: {r_['months']} months, {r_['first']} to {r_['last']}")
+                return 0
+            if a.remove:
+                _DCA.remove(ws, a.well, a.actor)
+                print(f"production removed from {a.well}")
+                return 0
+            if any(v is not None for v in terms.values()):
+                c_ = _DCA.set_config(ws, a.actor, a.well, a.source, **{k: v for k, v in terms.items() if v is not None})
+                print(f"{a.well}: terminal {c_['terminal_decline']:g}, price {c_['price_basis']}, NRI {c_['nri']:g}, severance {c_['severance']:g}, opex {c_['opex_month']:,.0f}/month, discount {c_['discount']:g}")
+                return 0
+            if a.write:
+                r_ = _DCA.write_report(ws, __version__, a.well, 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 = _DCA.page(ws, a.well, a.as_of)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"decline: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _DCA.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

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

@@ -11905,6 +11905,340 @@ def section_cu_pore_pressure(tmp: str) -> None:
        + (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 section_cw_decline(tmp: str) -> None:
+    """Section CW - decline curves: Arps's rate and cumulative and the modified hyperbolic against their closed forms
+    and the decline conversions; a production table built on known curves fitted back and forecast; the economic limit,
+    the discounted value and the SEC 12-month price; 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
+    from datetime import date as _date
+    import numpy as _np
+    from . import __version__ as _ver
+    from . import decline as DCA
+    from . import dossier as DZ
+    from . import edr as E
+    from . import helplib as H
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "decline"); d.mkdir()
+
+    # -- CW1 the curves by hand --------------------------------------------------------------------------------------------
+    qi, Di = 1000.0, 0.002
+    t = _np.array([0.0, 100.0, 1000.0])
+    e_ok = _np.allclose(DCA.rate(t, qi, Di, 0.0), qi * _np.exp(-Di * t)) and _np.allclose(DCA.cum(t, qi, Di, 0.0), qi / Di * (1 - _np.exp(-Di * t)))
+    h_ok = _np.allclose(DCA.rate(t, qi, Di, 0.5), qi / (1 + 0.5 * Di * t) ** 2) and _np.allclose(DCA.cum(t, qi, Di, 0.5), qi / (0.5 * Di) * (1 - (1 + 0.5 * Di * t) ** -1))
+    a_ok = _np.allclose(DCA.cum(t, qi, Di, 1.0), qi / Di * _np.log(1 + Di * t))
+    tt = _np.linspace(0, 20000, 200001)
+    q_mh = DCA.rate(tt, qi, Di, 1.5, 0.0002)
+    trap = float(_np.sum(0.5 * (q_mh[1:] + q_mh[:-1]) * _np.diff(tt)))
+    ts = (Di / 0.0002 - 1) / (1.5 * Di)
+    i_s = int(_np.searchsorted(tt, ts))
+    dq = _np.diff(_np.log(q_mh))
+    c1 = {
+        "arps": e_ok and h_ok and a_ok,
+        "modified": abs(float(DCA.cum(_np.array([20000.0]), qi, Di, 1.5, 0.0002)[0]) / trap - 1) < 1e-6 and abs(dq[i_s + 5] / 0.1 + 0.0002) < 1e-9 and q_mh[i_s - 1] > q_mh[i_s],
+        "conversions": abs(DCA.effective_annual(DCA.nominal_daily(0.65, 1.1), 1.1) - 0.65) < 1e-12 and abs(DCA.effective_annual(DCA.nominal_daily(0.08, 0.0), 0.0) - 0.08) < 1e-12
+                       and abs(DCA.effective_annual(0.001, 0.0) - (1 - _m.exp(-0.36525))) < 1e-12,
+        "sec": DCA.sec_price([f"2025-{m:02d}-0{k}" for m in range(1, 13) for k in (2, 3)] + ["2024-12-31"], [float(m * 10 + k) for m in range(1, 13) for k in (2, 3)] + [999.0],
+                             _date(2026, 1, 1))["price"] == round(sum(m * 10 + 2 for m in range(1, 13)) / 12.0, 4)
+               and DCA.sec_price(["2025-06-01"], [50.0], _date(2026, 1, 1)) is None,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CW1 Arps's curves by hand: the exponential, hyperbolic and harmonic rates and cumulatives in closed form; the modified "
+       "hyperbolic's cumulative equal to the integral of its rate, exponential at the terminal decline from the switch; the "
+       "effective and nominal declines inverse to each other; the SEC price the average of each month's first quote of the 12 "
+       "months before, and none when a month is missing"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CW2 a table built on known curves, fitted back ---------------------------------------------------------------------
+    f = DCA.selftest_files(str(d))
+    prod = DCA.read_production(Path(f["path"]).read_bytes())
+    so = DCA.analyse_stream(prod, "oil", {**DCA.DEFAULTS})
+    Dn, Dm = DCA.nominal_daily(f["De"], f["b"]), DCA.nominal_daily(f["Dterm"], 0.0)
+    th = _np.array(so["history"]["t"])
+    q_true = DCA.rate(th, f["qi"], Dn, f["b"], Dm)
+    q_fit = DCA.rate(th - so["t0_days"], so["fit"]["qi"], so["fit"]["Di"], so["fit"]["b"], so["Dmin"])
+    t_end = th[-1] + 30 * 365.25
+    eur_true = float(DCA.cum(_np.array([t_end]), f["qi"], Dn, f["b"], Dm)[0])
+    eur_fit = float(DCA.cum(_np.array([t_end - so["t0_days"]]), so["fit"]["qi"], so["fit"]["Di"], so["fit"]["b"], so["Dmin"])[0])
+    days_ok = all(abs(so["history"]["q"][i] - so["history"]["v"][i] / prod[i]["days"]) < 1e-3 for i in (7, 19))
+    XR.write_simple(str(d / "p.xlsx"), [["Production Month", "Oil Volume", "Gas Volume", "Days On"], ["2024-01", 3000, 6000, 31], ["2024-02", 2700, 5500, 29]])
+    px = DCA.read_production((d / "p.xlsx").read_bytes())
+    refused = 0
+    for bad in ("Month,Oil\n2024-01,-5\n", "Month,Oil\n2024-01,5\n2024-01,6\n", "Oil,Gas\n1,2\n", "Month,Oil,Days\n2024-01,5,40\n", "Month,Note\n2024-01,x\n"):
+        try:
+            DCA.read_production(bad.encode())
+        except ValueError:
+            refused += 1
+    c2 = {
+        "fit": abs(so["fit"]["b"] - f["b"]) <= 0.15 and float(_np.max(_np.abs(q_fit - q_true) / q_true)) < 0.04 and so["months_fitted"] == 48,
+        "eur": abs(eur_fit / eur_true - 1) < 0.05,
+        "days": days_ok,
+        "table": len(prod) == 48 and prod[0]["month"] == "2022-01" and px[1]["days"] == 29 and px[0]["oil"] == 3000 and refused == 5,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CW2 a well's 48 months built on a known curve (900 bbl/d, b 1.1, 65 % a year, 8 % terminal, 3 % noise, four months part "
+       "shut in) fitted back: b within 0.15, the rate within 4 % over the history, the 30-year recovery within 5 %; a part month's "
+       "rate its volume over its producing days; a table read from Excel by its names; a negative volume, a month twice, no month, "
+       "more than 31 days or no stream refused"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CW3 the forecast, the limit and the value ---------------------------------------------------------------------------
+    one = [{"month": f"2020-{m:02d}", "oil": 3000.0 * _m.exp(-0.01 * 30.4375 * (m - 1)), "gas": None, "water": None, "days": None} for m in range(1, 13)]
+    cfg = {**DCA.DEFAULTS, "terminal_decline": None, "nri": 1.0, "severance": 0.0, "opex_month": 0.0, "discount": 0.0, "years": 1.0}
+    r1 = DCA.analyse(one, cfg, {"oil": 50.0, "gas": 0.0})
+    vol12 = sum(m_["oil"] for m_ in r1["forecast"]["months"])
+    cfg2 = {**cfg, "opex_month": 500.0, "years": 20.0}
+    r2 = DCA.analyse(one, cfg2, {"oil": 50.0, "gas": 0.0})
+    last_net = r2["forecast"]["months"][-1]["net_usd"]
+    cfg3 = {**cfg, "discount": 0.10, "years": 1.0}
+    r3 = DCA.analyse(one, cfg3, {"oil": 50.0, "gas": 0.0})
+    pv_hand = sum(m_["net_usd"] * 1.1 ** (-((i + 0.5) / 12)) for i, m_ in enumerate(r3["forecast"]["months"]))
+    c3 = {
+        "exponential": r1["streams"]["oil"]["fit"]["b"] == 0.0 and abs(r1["streams"]["oil"]["fit"]["Di"] / (0.01) - 1) < 0.01 and len(r1["forecast"]["months"]) == 12
+                       and abs(r1["forecast"]["undiscounted_usd"] / (50.0 * vol12) - 1) < 1e-3,
+        "limit": r2["forecast"]["limit_month"] is not None and r2["forecast"]["stopped_by"] == "the economic limit" and last_net > 0
+                 and 3 <= len(r2["forecast"]["months"]) <= 12 and 50.0 * r2["forecast"]["months"][-1]["oil"] > 500.0,
+        "pv": abs(r3["forecast"]["pv_usd"] - pv_hand) < 2.0 and r3["forecast"]["pv_usd"] < r3["forecast"]["undiscounted_usd"],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CW3 the forecast: a year of exponential decline at 1 % a day fitted as exponential and carried a year forward, its revenue "
+       "the volume times the price; an operating cost stopping it at the economic limit on the last month that still pays; the "
+       "value discounted mid-month as by hand"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CW4 the API, the CLI, the report, the dossier, the tab and the help -------------------------------------------------
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wid = ws.add_well_file(ev["path"], display="PROD-1", actor="tester")["id"]
+    nothing = DCA.page(ws, wid)["detail"]
+    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())
+    content = Path(f["path"]).read_text(encoding="utf-8")
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_va, _ = call(V, "POST", "/api/decline/attach", {"well_id": wid, "filename": "p.csv", "content": content, "source": "x"})
+        s_ns, _ = call(O, "POST", "/api/decline/attach", {"well_id": wid, "filename": "p.csv", "content": content, "source": ""})
+        s_oa, oa = call(O, "POST", "/api/decline/attach", {"well_id": wid, "filename": "p.csv", "content": content, "source": "monthly report (test)"})
+        s_vg, vg = call(V, "GET", "/api/decline?well=" + wid + "&as_of=2026-01-01")
+        s_bt, _ = call(O, "POST", "/api/decline/settings", {"well_id": wid, "nri": 1.5, "source": "x"})
+        s_bp, _ = call(O, "POST", "/api/decline/settings", {"well_id": wid, "price_basis": "spot", "source": "x"})
+        s_ot, ot = call(O, "POST", "/api/decline/settings", {"well_id": wid, "price_basis": "flat", "oil_price": "70", "gas_price": "3", "source": "budget deck (test)"})
+        s_fg, fg = call(V, "GET", "/api/decline?well=" + wid)
+        s_vw, _ = call(V, "POST", "/api/decline/write", {"well_id": wid})
+        s_ow, ow = call(O, "POST", "/api/decline/write", {"well_id": wid})
+    finally:
+        svc.stop()
+    cli_t = _sp.run([sys.executable, "-m", "gea", "decline", "--workspace", wsp, "--well", wid], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_s = _sp.run([sys.executable, "-m", "gea", "decline", "--workspace", wsp, "--well", wid, "--opex", "9000", "--source", "LOE (test)"], 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": "production" in nothing and s_va == 403 and s_ns == 400 and s_oa == 200 and oa["months"] == 48 and s_vg == 200 and vg["result"]["as_of"] == "2026-01-01"
+               and "SEC average" in vg["result"]["price_how"]["oil"] and s_bt == 400 and s_bp == 400 and s_ot == 200 and ot["oil_price"] == 70.0
+               and s_fg == 200 and fg["result"]["prices"]["oil"] == 70.0 and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("DCA-"),
+        "cli": cli_t.returncode == 0 and "EUR" in cli_t.stdout and "70 USD/bbl declared" in cli_t.stdout and cli_s.returncode == 0 and "opex 9,000/month" in cli_s.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "wells", wid, "decline_curves.pdf")) and all(x in audit for x in ("production.attach", "production.terms", "report.decline_curves")),
+        "dossier": "declarations/economics/production/production.json" in names and f"declarations/economics/production/{wid}/p.csv" in names and f"results/decline/{wid}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.decline", "['#/decline', 'Decline curves']", "/api/decline/attach", "dcChart")),
+        "help": not H.check("decline") and H.VIEW_TOPIC.get("decline") == "decline",
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CW4 on the API (anyone reads a well's curves at a chosen date, valued at the SEC price; only an operator attaches production "
+       "- with its source - or declares terms - a net revenue interest of 1.5 or an unknown price basis refused - or writes the "
+       "report), the CLI, the report as PDF, a signed dossier carrying the production and the curves, 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:
@@ -12015,6 +12349,8 @@ def main() -> int:
         section_cs_plan_and_tools(tmp)
         section_ct_frac_hits(tmp)
         section_cu_pore_pressure(tmp)
+        section_cv_torque_drag(tmp)
+        section_cw_decline(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: