gea-program 0.57.0__tar.gz → 0.59.0__tar.gz

{gea_program-0.57.0/gea_program.egg-info → gea_program-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.57.0
+Version: 0.59.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
@@ -659,6 +659,31 @@ 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`.
 
+### The declarations workbook
+
+Everything the operator declares about a pad goes in through one sheet -
+`gea declare --workspace C:\site --template pad3.xlsx` writes it as an
+Excel workbook already filled with what is declared; `gea declare
+--workspace C:\site --file pad3.xlsx` checks it row by row and `--apply`
+writes it. Beside the wells, rates, runs and casing, it carries the
+engineering: the survey program and plans, pore pressure and measured
+pressures, the torque-and-drag string, the hydraulics (string, hole, mud,
+viscometer, nozzles), frac stage tables and monitored wells, production
+and the decline terms. A well with no directional survey is read on the
+drilling recorder's own Interpolated TVD where one is needed, labelled as
+the recorder's interpolation. `gea help declare`.
+
+### Hydraulics and ECD
+
+The pressures the mud makes while it circulates, from the six-speed
+viscometer (the API RP 13D power law: the pipe from 600/300, the annulus
+from 100/3): the standpipe pressure part by part - surface lines, string,
+motor and MWD, bit, annulus - the bit's hydraulics, the ECD at every depth
+against the pore pressure and fracture gradient, surge and swab and the
+fastest safe trip at each bit depth, and the standpipe pressure the rig
+measured against the model. The **Hydraulics & ECD** tab, `gea hydraulics`,
+`gea help hydraulics`.
+
 ### Torque and drag
 
 The hook load and torque the drill string should take at each bit depth, by

{gea_program-0.57.0 → gea_program-0.59.0}/README.md

@@ -620,6 +620,31 @@ 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`.
 
+### The declarations workbook
+
+Everything the operator declares about a pad goes in through one sheet -
+`gea declare --workspace C:\site --template pad3.xlsx` writes it as an
+Excel workbook already filled with what is declared; `gea declare
+--workspace C:\site --file pad3.xlsx` checks it row by row and `--apply`
+writes it. Beside the wells, rates, runs and casing, it carries the
+engineering: the survey program and plans, pore pressure and measured
+pressures, the torque-and-drag string, the hydraulics (string, hole, mud,
+viscometer, nozzles), frac stage tables and monitored wells, production
+and the decline terms. A well with no directional survey is read on the
+drilling recorder's own Interpolated TVD where one is needed, labelled as
+the recorder's interpolation. `gea help declare`.
+
+### Hydraulics and ECD
+
+The pressures the mud makes while it circulates, from the six-speed
+viscometer (the API RP 13D power law: the pipe from 600/300, the annulus
+from 100/3): the standpipe pressure part by part - surface lines, string,
+motor and MWD, bit, annulus - the bit's hydraulics, the ECD at every depth
+against the pore pressure and fracture gradient, surge and swab and the
+fastest safe trip at each bit depth, and the standpipe pressure the rig
+measured against the model. The **Hydraulics & ECD** tab, `gea hydraulics`,
+`gea help hydraulics`.
+
 ### Torque and drag
 
 The hook load and torque the drill string should take at each bit depth, by

{gea_program-0.57.0 → gea_program-0.59.0}/gea/__init__.py

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

{gea_program-0.57.0 → gea_program-0.59.0}/gea/__main__.py

@@ -533,11 +533,11 @@ def main(argv=None) -> int:
     p_ds.add_argument("--actor", type=str, default="cli")
     p_ds.add_argument("--json", action="store_true")
 
-    p_dc = sub.add_parser("declare", help="the declarations sheet: wells' identity, position and elevation, surveys, rates, items and AFEs, fleet tools, drill-string runs, ESP penetrators and drives - one CSV, checked against the workspace before anything is written")
+    p_dc = sub.add_parser("declare", help="the declarations sheet: wells' identity, position and elevation, surveys, rates, items and AFEs, fleet tools, drill-string runs, ESP penetrators and drives, the survey program and plans, pore pressure, torque and drag, hydraulics, frac stages, production - one CSV or Excel workbook, checked against the workspace before anything is written")
     p_dc.add_argument("--workspace", type=str, required=True)
     p_dc.add_argument("--file", type=str, default=None, help="the sheet (CSV); every row is planned NEW, CHANGE or SAME and nothing is written without --apply")
     p_dc.add_argument("--apply", action="store_true", help="write the NEW and CHANGE rows (only when the sheet has no error)")
-    p_dc.add_argument("--template", type=str, default=None, help="write the sheet for this workspace, filled with what is already declared, to this path")
+    p_dc.add_argument("--template", type=str, default=None, help="write the sheet for this workspace, filled with what is already declared, to this path (.xlsx: an Excel workbook; otherwise CSV)")
     p_dc.add_argument("--actor", type=str, default="cli")
     p_dc.add_argument("--json", action="store_true")
 
@@ -646,6 +646,24 @@ def main(argv=None) -> int:
     p_dc.add_argument("--actor", type=str, default="cli")
     p_dc.add_argument("--json", action="store_true")
 
+    p_hy = sub.add_parser("hydraulics", help="the pressures the mud makes while it circulates - the standpipe, the bit, the annulus, the ECD against the pore pressure and fracture gradient, surge and swab - and the standpipe pressure the rig measured")
+    p_hy.add_argument("--workspace", type=str, default=None)
+    p_hy.add_argument("--well", type=str, default=None)
+    p_hy.add_argument("--example", action="store_true", help="the worked example (Volve 15/9-F-10 with an example mud, string and hole)")
+    p_hy.add_argument("--string", type=str, default=None, help="sections from the bit up: 'BHA:350:6.75:2.875; drill pipe::5:4.276' (what:length_ft:od_in:id_in)")
+    p_hy.add_argument("--hole", type=str, default=None, help="sections from the surface down: '9-5/8 casing:3500:8.681; open hole::8.75' (what:bottom_md_ft:id_in)")
+    p_hy.add_argument("--fann", type=str, default=None, help="the viscometer dial: '600=60 300=38 200=30 100=21 6=7 3=6'")
+    p_hy.add_argument("--nozzles", type=str, default=None, help="nozzle sizes in 32nds of an inch: '14 14 14 14 14'")
+    for k_, h_ in (("mw", "mud weight, ppg"), ("flow", "pump rate, gal/min"), ("bit", "bit diameter, in"), ("surface", "surface lines' pressure loss, psi"),
+                   ("surface-ref", "the rate (gal/min) the surface loss was declared at"), ("tools", "motor and MWD pressure drop, psi"),
+                   ("trip", "average stand speed tripping, ft/min"), ("pp", "a pore pressure for the hole when the Pore pressure tab has none, ppg"),
+                   ("fg", "a fracture gradient for the hole when the Pore pressure tab has none, ppg")):
+        p_hy.add_argument("--" + k_, type=str, default=None, help=h_)
+    p_hy.add_argument("--source", type=str, default="", help="where the mud, string and hole figures came from")
+    p_hy.add_argument("--write", action="store_true")
+    p_hy.add_argument("--actor", type=str, default="cli")
+    p_hy.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)
@@ -2334,8 +2352,11 @@ def main(argv=None) -> int:
         except WorkspaceError as e:
             raise SystemExit(f"declare: {e}")
         if a.template:
-            with open(a.template, "w", encoding="utf-8", newline="") as f:
-                f.write(_DC.template(ws))
+            if a.template.lower().endswith(".xlsx"):
+                _DC.template_xlsx(ws, a.template)
+            else:
+                with open(a.template, "w", encoding="utf-8", newline="") as f:
+                    f.write(_DC.template(ws))
             print(f"wrote {a.template}: fill in the blanks, then gea declare --workspace {a.workspace} --file {a.template}")
             return 0
         if not a.file:
@@ -2577,6 +2598,46 @@ def main(argv=None) -> int:
             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 == "hydraulics":
+        import json as _json
+        from . import hydraulics as _HYD
+        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_ = {"mw": "mw_ppg", "flow": "flow_gpm", "bit": "bit_in", "surface": "surface_psi", "surface_ref": "surface_ref_gpm", "tools": "tools_psi",
+                     "trip": "trip_ft_min", "pp": "pp_ppg", "fg": "fg_ppg"}
+            vals_ = {v: getattr(a, k) for k, v in keys_.items() if getattr(a, k) is not None}
+            if ws is not None and (vals_ or any(x is not None for x in (a.string, a.hole, a.fann, a.nozzles))):
+                if not a.well:
+                    raise ValueError("--well is needed")
+                fann_ = None
+                if a.fann is not None:
+                    fann_ = {}
+                    for p_ in a.fann.replace(",", " ").split():
+                        k_, _, v_ = p_.partition("=")
+                        if not v_:
+                            raise ValueError(f"--fann takes SPEED=DIAL pairs, e.g. 600=60 300=38, not {p_!r}")
+                        fann_[k_.strip()] = v_.strip()
+                c_ = _HYD.set_well(ws, a.actor, a.well, a.source, a.string, a.hole, fann_, a.nozzles, **vals_)
+                print(f"{a.well}: mud {c_['mw_ppg']:g} ppg, {c_['flow_gpm']:g} gpm; string {len(c_.get('string') or [])} section(s), hole {len(c_.get('hole') or [])} section(s); "
+                      f"viscometer {' '.join(f'{k}={v:g}' for k, v in (c_.get('fann') or {}).items()) or 'not declared'}")
+                return 0
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _HYD.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 = _HYD.page(ws, scene, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"hydraulics: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _HYD.text(r))
+        return 0
     elif a.cmd == "torque-drag":
         import json as _json
         from . import torque_drag as _TND

{gea_program-0.57.0 → gea_program-0.59.0}/gea/acceptance_tests.py

@@ -12821,6 +12821,323 @@ def section_cz_it_review(tmp: str) -> None:
        "SECURITY.md says how to report a vulnerability" + (f" - failed: {failed3}" if failed3 else ""))
 
 
+def section_da_hydraulics(tmp: str) -> None:
+    """Section DA - hydraulics and ECD: the power law's losses against their closed forms (Hagen-Poiseuille, the slot,
+    Blasius) and API RP 13D's field-unit forms, the bit against its classic formula; a record whose standpipe pressure is
+    the model's plus a known amount, read back; the worked example's ECD against its window, surge and swab; 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 . import __version__ as _ver
+    from . import dossier as DZ
+    from . import helplib as H
+    from . import hydraulics as HY
+    from . import well3d as W
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "hydraulics"); d.mkdir()
+
+    # -- DA1 by hand --------------------------------------------------------------------------------------------------------
+    mu, q = 0.03, 50.0
+    lp = HY.pipe_loss(q, 4.0, 1000.0, 8.33, 1.0, mu)
+    Q, D = q * HY.GPM, 4.0 * HY.IN
+    V = Q / (_m.pi * D * D / 4.0)
+    hp = 32.0 * mu * V * 1000.0 * HY.FT / D ** 2 / HY.PSI
+    la = HY.annulus_loss(q, 8.5, 5.0, 1000.0, 8.33, 1.0, mu)
+    Va = q * HY.GPM / (_m.pi * ((8.5 * HY.IN) ** 2 - (5.0 * HY.IN) ** 2) / 4.0)
+    slot = 48.0 * mu * Va * 1000.0 * HY.FT / (3.5 * HY.IN) ** 2 / HY.PSI
+    f_t = HY.friction(1e5, 1.0, 16.0)[0]
+    rh = HY.rheology({"600": 56, "300": 36, "200": 28, "100": 20, "6": 6, "3": 5})
+    n, K = rh["n_pipe"], rh["K_pipe"]
+    api = HY.pipe_loss(550.0, 4.276, 1000.0, 10.5, n, K)
+    Vf = 24.51 * 550.0 / 4.276 ** 2                                   # ft/min
+    mu_api = 100.0 * (5.11 * 56 / 1022 ** n) * (1.6 * Vf / 4.276) ** (n - 1) * ((3 * n + 1) / (4 * n)) ** n
+    re_api = 15.467 * Vf * 4.276 * 10.5 / mu_api
+    dp_api = 1.076 * 10.5 * Vf ** 2 * api["f"] / 1e5 / 4.276 * 1000.0
+    bt = HY.bit(550.0, 10.5, [13] * 6, 8.5)
+    refused = []
+    for bad in ({"600": 56}, {"600": 30, "300": 36}, {"600": 56, "300": 36, "450": 40}, {"600": 400, "300": 36}):
+        try:
+            HY.rheology(bad); refused.append(False)
+        except ValueError:
+            refused.append(True)
+    for fn, arg in ((HY.check_string, [{"what": "x", "length_ft": 100, "od_in": 5, "id_in": 6}]), (HY.check_hole, [{"what": "a", "bottom_md_ft": 1000, "id_in": 8},
+                                                                                                                       {"what": "b", "bottom_md_ft": 500, "id_in": 8}, {"what": "c", "id_in": 8}]),
+                    (HY.parse_sections, "BHA:300:6.75"), (HY.annulus_loss, None)):
+        try:
+            fn(arg, "string") if fn is HY.parse_sections else (HY.annulus_loss(500, 5.0, 6.0, 100, 10, 0.5, 0.5) if fn is HY.annulus_loss else fn(arg))
+            refused.append(False)
+        except ValueError:
+            refused.append(True)
+    c1 = {
+        "newtonian": abs(lp["psi"] / hp - 1) < 1e-4 and lp["regime"] == "laminar" and abs(la["psi"] / slot - 1) < 1e-9 and abs(f_t / (0.0791 / 1e5 ** 0.25) - 1) < 0.01,
+        "rheology": rh["pv_cp"] == 20 and rh["yp_lbf_100ft2"] == 16 and abs(rh["n_pipe"] - _m.log2(56 / 36)) < 1e-4 and abs(rh["n_ann"] - _m.log(20 / 5) / _m.log(170.2 / 5.11)) < 1e-4
+                    and rh["tau0_lbf_100ft2"] == 4 and rh["annulus_from"] == "100 and 3 rpm",
+        "api_forms": abs(api["v_ft_min"] / Vf - 1) < 1e-3 and abs(api["mu_cp"] / mu_api - 1) < 1e-3 and abs(api["re"] / re_api - 1) < 2e-3 and abs(api["psi"] / dp_api - 1) < 1e-3,
+        "bit": abs(bt["psi"] / (156.5 * 10.5 * 550.0 ** 2 / (6 * 13 ** 2) ** 2) - 1) < 1e-3 and abs(bt["tfa_in2"] - 6 * _m.pi / 4 * (13 / 32) ** 2) < 1e-3
+               and abs(bt["hhp"] - bt["psi"] * 550 / 1714) < 0.1,
+        "refused": all(refused) and len(refused) == 8,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DA1 the losses by hand: a Newtonian fluid's laminar loss in a pipe is Hagen-Poiseuille's and in the annulus the slot's, exactly; its turbulent "
+       "friction factor Blasius's to 1 %; the viscometer's PV, YP, the pipe's n from 600/300 and the annulus's from 100/3; the velocity, effective "
+       "viscosity, Reynolds number and loss equal to API RP 13D's field-unit forms; the bit's loss the classic 156.5 rho Q^2 / (sum d^2)^2; readings "
+       "missing, falling or out of range, a bore wider than the pipe, a hole out of order, a short section and a pipe wider than its hole refused"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DA2 a record made by the model, read back ---------------------------------------------------------------------------
+    f = HY.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wid = ws.add_well_file(f["record"], display="HY-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 = HY.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_decl = HY.page(ws, "workspace", wid)["detail"]
+    c = f["config"]
+    HY.set_well(ws, "tester", wid, "mud report (test)", string=c["string"], hole=c["hole"], fann=c["fann"], nozzles_32=c["nozzles_32"], mw_ppg=c["mw_ppg"],
+                flow_gpm=500, bit_in=8.75, tools_psi=400, pp_ppg=9.5, fg_ppg=14.5)
+    r = HY.page(ws, "workspace", wid)["result"]
+    rc = r["record"]
+    cc = r["circulating"]
+    c2 = {
+        "needs": "survey" in no_survey and "string" in no_decl and "viscometer" in no_decl,
+        "record": rc and rc["bins"] >= 20 and abs(rc["median_difference_psi"] - f["offset_psi"]) <= 10.0 and rc["spread_psi"] < 30.0,
+        "parts": abs(sum(cc["parts"].values()) - cc["spp_psi"]) < 1.0 and cc["parts"]["tools"] == 400.0 and cc["parts"]["surface"] == 0.0,
+        "ecd": cc["ecd_bit_ppg"] > c["mw_ppg"] and all(e_ >= c["mw_ppg"] for e_ in r["ecd"]["ecd_ppg"])
+               and abs(cc["ecd_bit_ppg"] - (c["mw_ppg"] + cc["parts"]["annulus"] / (0.052 * cc["tvd_bit_ft"]))) < 0.002,
+        "window": r["window_how"].startswith("declared") and r["min_fg_margin"]["ppg"] == min(x for x in r["ecd"]["margin_fg_ppg"] if x is not None),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DA2 a drilling record made by the model - drilling from 4,000 to 10,000 ft at 500 gpm and circulating at 350 gpm, its standpipe pressure the "
+       "model's plus 120 psi and noise - read back while pumping: the median difference 120 psi to within 10 over 20 or more depth bins; the standpipe "
+       "pressure the sum of its parts; the ECD at the bit the mud weight plus the annular loss over 0.052 TVD; a well without a survey or its "
+       "declarations says what it needs" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- DA3 the worked example ----------------------------------------------------------------------------------------------
+    ex = HY.example()
+    t = ex["trips"]
+    s_hi = HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], 180.0, lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])
+    s_lo = HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], 90.0, lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])
+    rates = ex["by_rate"]
+    c3 = {
+        "example": ex["well"] == "15/9-F-10" and abs(ex["td_ft"] - 5300.07 / 0.3048) < 5.0 and "not from Volve" in ex["config"]["source"]
+                   and 2000 < ex["circulating"]["spp_psi"] < 5000 and ex["circulating"]["ecd_bit_ppg"] > ex["config"]["mw_ppg"],
+        "rates": all(b["spp_psi"] > a["spp_psi"] and b["ecd_bit_ppg"] >= a["ecd_bit_ppg"] for a, b in zip(rates, rates[1:])),
+        "surge": all(su > ex["config"]["mw_ppg"] > sw for su, sw in zip(t["surge_ppg"], t["swab_ppg"])) and s_hi["psi"] > s_lo["psi"] > 0,
+        "speeds": all(v is not None and v > 0 for v in t["run_max_ft_min"] + t["pull_max_ft_min"])
+                  and HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], t["run_max_ft_min"][-1], lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])["surge_ppg"] <= 14.0 + 0.02,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "DA3 the worked example, Volve 15/9-F-10's survey to its 5,300 m TD with a mud, string and hole declared for the example: the standpipe pressure "
+       "and the ECD rising with the rate; surge above and swab below the mud weight at every bit depth, more at a faster trip; the fastest run keeping "
+       "the surge within the declared fracture gradient" + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- DA4 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/hydraulics?well=" + wid)
+        s_ve, ve = call(V_, "GET", "/api/hydraulics?scene=example")
+        s_vs, _ = call(V_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": 11.2, "source": "x"})
+        s_os, os_ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": "11.2", "r600": "62", "r300": "40", "r100": "22", "r3": "6",
+                                                                  "nozzles_32": "13 13 13 13 13", "hole": "9-5/8 casing:3500:8.681; open hole::8.75", "source": "mud report (test)"})
+        s_bf, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "r600": "30", "r300": "40", "source": "x"})
+        s_bh, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "flow_gpm": 9000, "source": "x"})
+        s_ns, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": 12})
+        s_vw, _ = call(V_, "POST", "/api/hydraulics/write", {"well_id": wid})
+        s_ow, ow = call(O_, "POST", "/api/hydraulics/write", {"well_id": wid})
+    finally:
+        svc.stop()
+    cli_x = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--example"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_s = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--workspace", wsp, "--well", wid, "--flow", "450", "--fann", "600=60 300=38 100=21 3=6",
+                     "--source", "mud report (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_b = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--workspace", wsp, "--well", wid, "--fann", "600:60", "--source", "x"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--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"]["record"]["bins"] >= 20 and s_ve == 200 and ve["result"]["well"] == "15/9-F-10" and s_vs == 403 and s_os == 200
+               and os_["fann"] == {"600": 62.0, "300": 40.0, "100": 22.0, "3": 6.0} and os_["nozzles_32"] == [13.0] * 5 and os_["mw_ppg"] == 11.2
+               and s_bf == 400 and s_bh == 400 and s_ns == 400 and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("HYD-"),
+        "cli": cli_x.returncode == 0 and "standpipe" in cli_x.stdout and "ECD at the bit" in cli_x.stdout and cli_s.returncode == 0 and "450 gpm" in cli_s.stdout
+               and cli_b.returncode != 0 and "SPEED=DIAL" in (cli_b.stderr + cli_b.stdout) and cli_t.returncode == 0 and "against the record" in cli_t.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "wells", wid, "hydraulics.pdf")) and all(x in audit for x in ("hydraulics.declare", "report.hydraulics")),
+        "dossier": "declarations/drillstring/hydraulics.json" in names and f"results/hydraulics/{wid}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.hydraulics", "['#/hydraulics', 'Hydraulics & ECD']", "/api/hydraulics/settings", "hyChart", "hySppChart")),
+        "help": not H.check("hydraulics") and H.VIEW_TOPIC.get("hydraulics") == "hydraulics",
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DA4 the tab's data for a viewer (the well, the worked example); the declarations by an operator only, with a source, readings and rates in "
+       "range; `gea hydraulics` prints the example and a well and declares the viscometer as SPEED=DIAL; the report with its PDF, audited; the "
+       "signed dossier carries the declarations and the result; the tab and the help page"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
+def section_db_declarations_engineering(tmp: str) -> None:
+    """Section DB - the declarations sheet carries the engineering: the survey program, a plan, the pore-pressure
+    settings and a measured pressure, the torque-and-drag string, the hydraulics, a frac stage table and its monitor,
+    production and the decline terms - planned NEW, written, then SAME on a second import and from the template; every
+    malformed row refused with nothing written; the sheet as an Excel workbook; a well with no survey read on the
+    drilling recorder's own TVD, labelled so."""
+    import csv as _csv
+    import io as _io
+    import shutil as _sh
+    import subprocess as _sp
+    from . import __version__ as _ver
+    from . import declarations as DC
+    from . import decline as DCA
+    from . import edr as E
+    from . import frac_hits as FH
+    from . import helplib as H
+    from . import hydraulics as HY
+    from . import pore_pressure as PPF
+    from . import torque_drag as TND
+    from . import wellplan as WPL
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+    d = Path(tmp, "declare_eng"); d.mkdir()
+    hy = HY.selftest_files(str(d / "hy"))
+    fh = FH.selftest_files(str(d / "fh"))
+    dc = DCA.selftest_files(str(d / "dc"))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w1 = ws.add_well_file(hy["record"], display="HY-1", actor="tester")["id"]
+    w2 = ws.add_well_file(fh["gauge"], display="MON-1", actor="tester")["id"]
+    sheet_dir = d / "sheet"; sheet_dir.mkdir()
+    _sh.copy(hy["survey"], sheet_dir / "plan.csv"); _sh.copy(fh["stages"], sheet_dir / "stages.csv"); _sh.copy(dc["path"], sheet_dir / "production.csv")
+    rows = [
+        ["[survey_program]", "well", "program", "source"], ["", "HY-1", "0-1000:MWD+SRGM, 1000-:MWD+IFR1", "survey program rev 1 (test)"],
+        ["[plans]", "well", "file", "azimuth_reference", "md_unit", "source"], ["", "HY-1", "plan.csv", "true", "ft", "well plan rev 2 (test)"],
+        ["[pore_pressure]", "well", "indicator", "bit_in", "nct_top_m", "nct_bottom_m", "source"], ["", "HY-1", "dexponent", "8.75", "1300", "2000", "drilling program (test)"],
+        ["[pressures]", "well", "depth_m", "depth_kind", "value", "unit", "kind", "source"], ["", "HY-1", "2100", "tvd", "13.5", "ppg", "lot", "LOT at the 9-5/8 shoe (test)"],
+        ["[torque_drag]", "well", "string", "mud_ppg", "mu_cased", "mu_open", "source"], ["", "HY-1", "BHA:350:6.75:95:6.75; drill pipe::5:22.6:6.625", "11", "0.2", "0.28", "BHA report (test)"],
+        ["[hydraulics]", "well", "string", "hole", "mw_ppg", "fann", "flow_gpm", "nozzles_32", "bit_in", "tools_psi", "pp_ppg", "fg_ppg", "source"],
+        ["", "HY-1", "BHA:350:6.75:2.875; drill pipe::5:4.276", "9-5/8 casing:3500:8.681; open hole::8.75", "11", "600=60 300=38 100=21 6=7 3=6", "500",
+         "14 14 14 14 14", "8.75", "400", "9.5", "14.5", "mud report (test)"],
+        ["[frac_stages]", "well", "file", "depth_unit", "source"], ["", "HY-1", "stages.csv", "ft", "post-job report (test)"],
+        ["[frac_monitors]", "well", "channel"], ["", "MON-1", "P_gauge_psi"],
+        ["[production]", "well", "file", "source"], ["", "HY-1", "production.csv", "monthly report (test)"],
+        ["[decline_terms]", "well", "terminal_decline", "price_basis", "oil_price", "gas_price", "opex_month", "source"], ["", "HY-1", "0.08", "flat", "70", "3", "9000", "budget deck (test)"],
+    ]
+    buf = _io.StringIO(); _csv.writer(buf, lineterminator="\n").writerows(rows); text = buf.getvalue()
+    p1 = DC.apply(ws, text, "tester", str(sheet_dir))
+    a1 = DC.apply(ws, text, "tester", str(sheet_dir), write=True)
+    p2 = DC.apply(ws, text, "tester", str(sheet_dir))
+    tpl = DC.template(ws)
+    pt = DC.apply(ws, tpl, "tester", str(sheet_dir))
+    hcfg, tcfg, pcfg = HY.well_config(ws, w1), TND.well_config(ws, w1), PPF.well_config(ws, w1)
+    meas = (PPF._load(ws).get("measured") or {}).get(w1) or []
+    c1 = {
+        "planned": not p1["errors"] and p1["counts"]["NEW"] == 10 and p1["counts"]["CHANGE"] == 0 and sorted({s["table"] for s in p1["steps"]}) == sorted(DC.ENG_ORDER),
+        "written": a1["applied"] and len(a1["written"]) == 10,
+        "landed": WPL.well_settings(ws, w1)["program"] == [{"to_md_m": 1000.0, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+IFR1"}]
+                  and bool(ws.well(w1).get("plan")) and pcfg["indicator"] == "dexponent" and pcfg["bit_in"] == 8.75
+                  and meas and meas[0]["kind"] == "lot" and meas[0]["unit"] == "ppg" and len(tcfg["string"]) == 2 and tcfg["mu_open"] == 0.28
+                  and hcfg["fann"] == {"600": 60.0, "300": 38.0, "100": 21.0, "6": 7.0, "3": 6.0} and hcfg["nozzles_32"] == [14.0] * 5 and len(hcfg["hole"]) == 2
+                  and FH.stages(ws).get(w1, {}).get("stages") == 6 and FH.settings(ws)["monitors"].get(w2, {}).get("channel") == "P_gauge_psi"
+                  and DCA.production(ws, w1) and DCA.well_config(ws, w1)["oil_price"] == 70.0,
+        "again": not p2["errors"] and p2["counts"]["NEW"] == 0 and p2["counts"]["CHANGE"] == 0 and p2["counts"]["SAME"] == 10,
+        "template": not pt["errors"] and pt["counts"]["NEW"] == 0 and pt["counts"]["CHANGE"] == 0 and all(f"[{t}]" in tpl for t in DC.ENG_ORDER),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DB1 one sheet carries the engineering - the survey program, a plan, the pore-pressure settings and a leak-off test, the torque-and-drag string, "
+       "the hydraulics (string, hole, mud, viscometer, nozzles), a frac stage table and its monitored well, production and the decline terms: ten rows "
+       "planned NEW, written through each tab's own function, SAME on a second import; the template lists every table and carries what is declared, "
+       "so importing it writes nothing" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DB2 every malformed row refused, nothing written ---------------------------------------------------------------------
+    bad = {
+        "survey_program": ["", "HY-1", "0-1000:NO-SUCH-TOOL", "x"], "plans": ["", "HY-1", "missing.csv", "true", "ft", "x"],
+        "pore_pressure": ["", "HY-1", "dexponent", "99", "1300", "2000", "x"], "pressures": ["", "HY-1", "2100", "tvd", "13.5", "ppg", "guess", "x"],
+        "torque_drag": ["", "HY-1", "BHA:350", "11", "0.2", "0.28", "x"],
+        "hydraulics": ["", "HY-1", "", "", "11", "600:60", "500", "40 40", "8.75", "400", "9.5", "14.5", "x"],
+        "frac_stages": ["", "HY-1", "stages.csv", "yards", "x"], "decline_terms": ["", "HY-1", "0.08", "spot", "70", "3", "9000", "x"],
+    }
+    errs = {}
+    for t, r in bad.items():
+        hdr = next(x for x in rows if x[0] == f"[{t}]")
+        b_ = _io.StringIO(); _csv.writer(b_, lineterminator="\n").writerows([hdr, r]); bp = DC.apply(ws, b_.getvalue(), "tester", str(sheet_dir), write=True)
+        errs[t] = (len(bp["errors"]) == 1 and not bp["written"] and not bp["applied"])
+    mixed = rows[:2] + [["[pressures]", "well", "depth_m", "value", "kind", "source"], ["", "HY-1", "-5", "13", "pore", "x"]]
+    b_ = _io.StringIO(); _csv.writer(b_, lineterminator="\n").writerows(mixed); mp = DC.apply(ws, b_.getvalue(), "tester", str(sheet_dir), write=True)
+    ok(all(errs.values()) and len(mp["errors"]) == 1 and not mp["written"],
+       "DB2 a tool model that does not exist, a plan file that is not there, a bit size out of range, a pressure of no known kind, a string section "
+       "short of its figures, a viscometer pair without '=' and nozzles over 32/32, a depth unit of yards, a price basis of 'spot' - each refused with "
+       "its row named; a sheet with one bad row writes none of its good rows"
+       + (f" [failed: {', '.join(k for k, v in errs.items() if not v)}]" if not all(errs.values()) else ""))
+
+    # -- DB3 the sheet as an Excel workbook --------------------------------------------------------------------------------
+    xp = str(d / "declarations.xlsx")
+    DC.template_xlsx(ws, xp)
+    xb = Path(xp).read_bytes()
+    px = DC.apply(ws, XR.text_of(xb), "tester", str(sheet_dir))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--template", str(d / "t2.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_p = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--file", str(d / "t2.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    ok(XR.is_xlsx(xb) and not px["errors"] and px["counts"]["NEW"] == 0 and px["counts"]["CHANGE"] == 0 and px["counts"]["SAME"] >= 10
+       and cli_t.returncode == 0 and XR.is_xlsx(Path(d / "t2.xlsx").read_bytes()) and cli_p.returncode == 0 and "nothing to write" in cli_p.stdout,
+       "DB3 the template as an Excel workbook (gea declare --template declarations.xlsx, and the Download on the Setup page): a workbook the import "
+       "reads back to the same plan - nothing new to write")
+
+    # -- DB4 no survey: the recorder's own TVD -------------------------------------------------------------------------------
+    st = E.read(hy["record"])
+    out = Path(ws.reports_dir, "wells", w1); out.mkdir(parents=True, exist_ok=True)
+    E.write_record(st, str(out), _ver)
+    rp = HY.recorder_path(ws, w1)
+    r_h = HY.page(ws, "workspace", w1)["result"]
+    TND.set_well(ws, "tester", w1, "BHA report (test)", TND.parse_string("BHA:350:6.75:95:6.75; drill pipe::5:22.6:6.625"), 11)
+    r_t = TND.page(ws, "workspace", w1)["result"]
+    from . import well3d as W
+    W.attach_trajectory(ws, w1, "s.csv", Path(hy["survey"]).read_bytes(), "tester", "true", "ft", None, None, None, "test survey")
+    r_s = HY.page(ws, "workspace", w1)["result"]
+    help_txt = H.page("declare") or ""
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "path": rp and rp["md_ft"][0] == 0.0 and abs(max(rp["tvd_ft"]) - 7480.0) < 30.0 and max(rp["inc_deg"]) <= 61.0 and "not a survey" in rp["source"],
+        "hydraulics": r_h and r_h["path_from"] == "recorder" and "Interpolated TVD" in r_h["how"] and abs(r_h["record"]["median_difference_psi"] - hy["offset_psi"]) <= 10.0
+                      and abs(r_h["tvd_td_ft"] - r_s["tvd_td_ft"]) < 30.0,
+        "torque_drag": r_t and r_t["path_from"] == "recorder" and "one vertical plane" in r_t["how"] and 55.0 <= r_t["max_inc_deg"] <= 61.0,
+        "survey_first": r_s["path_from"] == "survey",
+        "help": not H.check("declare") and all(f"[{t}]" in help_txt for t in DC.ENG_ORDER) and "Interpolated TVD" in (H.page("hydraulics") or "")
+                and "/api/declare/template?format=xlsx" in page_src,
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DB4 a well with no survey attached is read on the drilling recorder's own Interpolated TVD, labelled as the recorder's interpolation and not a "
+       "survey: the hydraulics' TVDs within 30 ft of the survey's and the standpipe offset recovered the same; torque and drag on an inclination-only path "
+       "in one vertical plane, said so; a survey, once attached, is used instead; the help names every table"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -12936,6 +13253,8 @@ def main() -> int:
         section_cx_https(tmp)
         section_cy_company_sign_in(tmp)
         section_cz_it_review(tmp)
+        section_da_hydraulics(tmp)
+        section_db_declarations_engineering(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: