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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.52.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,18 @@ 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

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

@@ -609,6 +609,18 @@ 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

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

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

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

@@ -622,6 +622,20 @@ 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)
@@ -2472,6 +2486,35 @@ 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

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

@@ -11905,6 +11905,166 @@ 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 PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -12015,6 +12175,7 @@ def main() -> int:
         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.52.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'), ('geomech', 'pore_pressure.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, each declared well's pore pressure and the
-    frac-hit check, as JSON computed when the dossier is signed (a check that cannot run is left out, and says why)."""
+    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,17 @@ def _results(ws, well_id: Optional[str]) -> List[tuple]:
                                                                                  indent=1, sort_keys=True, default=str).encode('utf-8')))
     except Exception as e:
         out.append(('results/collision_not_run.txt', f'the collision check did not run: {type(e).__name__}: {e}\n'.encode('utf-8')))
+    try:
+        from . import 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 {})

gea_program-0.53.0/gea/help/torque-drag.md

@@ -0,0 +1,17 @@
+# Torque and drag
+
+> The hook load and torque the drill string should take at each bit depth, by the soft-string model: pulling out (pick-up), running in (slack-off) and rotating off bottom, for the declared friction factors and a fan of others (the broomstick); against the rig's own hook loads and torque from the drilling record, 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 command**: the **Torque & drag** tab: the hook load against bit depth - pick-up, slack-off and rotating for the declared friction factors, faint lines for 0.1 to 0.5, the rig's own points - and the off-bottom torque; the friction factors that fit the rig; the string, the mud, the friction factors and the block weight (the operator role); **Write the report**. From a terminal: `gea torque-drag --workspace C:\site --well W` prints it; `--example` the worked example; `--string "BHA:300:6.75:95; drill pipe::5:22.6:6.625" --mud 10 --mu-cased 0.25 --mu-open 0.3 --block 40 --source "BHA report, pipe tally"` declares the string; `--write` writes the report.
+
+**What it needs**: the well's directional survey; the string, from the bit up - each section's name, length (ft; the top section has none: it runs to the surface), outside diameter (in), weight per foot in air with its tool joints (lb/ft) and the diameter it turns on (in; the tool joint's) - with the mud density and its source. The deepest casing shoe declared (Rig time) divides cased from open hole. For the rig's side, a drilling record with hook load, bit depth and hole depth (block height, pump output or standpipe pressure, rotary speed and torque when it has them).
+
+**How it is computed**: the soft-string model of Johancsik, Friesen and Dawson (SPE-11380-PA, 1984), element by element from the bit up every 30 ft of the survey's arcs: the normal force N = sqrt((F d_alpha sin theta)^2 + (W sin theta - F d_theta)^2) from the tension below F and the buoyed weight W (weight in air times 1 - mud/65.5 ppg); the tension above F + W cos theta plus (pulling out) or minus (running in) mu N, or without friction rotating; the torque plus mu N r rotating, r the contact radius. The hook load is the surface tension plus the travelling block, declared or estimated from the record (the rig-time rule). From the record, the rig states of Rig time give the hook load tripping out and in with the pumps off, and the hook load and torque rotating off bottom with the pumps on; each is the median of each 100 ft of bit depth. The friction factor that fits each is found over the bins in cased hole first, then in open hole with the cased factor held.
+
+**What it writes**: the string and its figures in `drillstring\torque_drag.json` (audit line `torque_drag.declare`), the audit line `report.torque_drag`, and the reports `reports\wells\<well>\torque_drag.*` (or `reports\torque_drag_example.*`; PDF, HTML, markdown, JSON).
+
+**The number to check**: the string's buoyed weight against the hook load of a vertical well at TD less the block; one depth's pick-up against the driller's broomstick sheet; a fitted friction factor against the field's usual range.
+
+**What this page will not call a measurement**: the friction factor - it is fitted, a number that makes the model match the rig, not a property measured in the hole. Where the string touches - the soft-string model lays the string on the hole as a cable, without its stiffness or the hole's clearance. Buckling - a string pushed past its buckling load in compression is not modelled.
+
+**Sources**: Johancsik, Friesen and Dawson, "Torque and Drag in Directional Wells - Prediction and Measurement", SPE-11380-PA, JPT 36(6), 1984. The worked example: Volve 15/9-F-10's survey (Equinor's released data) with a string, mud and friction factors declared for the example.

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

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

{gea_program-0.52.0 → gea_program-0.53.0}/gea/service.py

@@ -1921,6 +1921,9 @@ def make_handler(app: App):
                 if path == '/api/plan':
                     from . import wellplan as WPL
                     return self._json(200, App._cr(WPL.page, app.ws, (qs.get('well') or [None])[0]))
+                if path == '/api/torque-drag':
+                    from . import torque_drag as TND
+                    return self._json(200, App._cr(TND.page, app.ws, (qs.get('scene') or ['workspace'])[0], (qs.get('well') or [None])[0]))
                 if path == '/api/pore-pressure':
                     from . import pore_pressure as PPF
                     return self._json(200, App._cr(PPF.page, app.ws, (qs.get('scene') or ['workspace'])[0], (qs.get('well') or [None])[0]))
@@ -2341,6 +2344,20 @@ def make_handler(app: App):
                         return self._json(200, App._cr(RS.remove_casing, app.ws, user['name'], str(b_.get('well_id') or ''), str(b_.get('size') or '')))
                     return self._json(200, App._cr(RS.set_casing, app.ws, user['name'], str(b_.get('well_id') or ''), str(b_.get('size') or ''),
                                                    b_.get('shoe_md_ft'), str(b_.get('source') or ''), b_.get('set')))
+                if path in ('/api/torque-drag/settings', '/api/torque-drag/write'):
+                    from . import torque_drag as TND
+                    from . import __version__ as _v
+                    App.require(user, 'operator')
+                    b_ = dict(body or {})
+                    wid = str(b_.get('well_id') or '')
+                    if path.endswith('/settings'):
+                        st_ = b_.get('string')
+                        if isinstance(st_, str):
+                            st_ = App._cr(TND.parse_string, st_) if st_.strip() else None
+                        return self._json(200, App._cr(TND.set_well, app.ws, user['name'], wid, str(b_.get('source') or ''), st_, b_.get('mud_ppg'),
+                                                       b_.get('mu_cased'), b_.get('mu_open'), b_.get('block_klbf')))
+                    r_ = App._cr(TND.write_report, app.ws, _v, wid or None, user['name'], str(b_.get('scene') or 'workspace'))
+                    return self._json(200, {'report_id': r_['report_id']})
                 if path in ('/api/pore-pressure/settings', '/api/pore-pressure/measure', '/api/pore-pressure/unmeasure', '/api/pore-pressure/write'):
                     from . import pore_pressure as PPF
                     from . import __version__ as _v